376 lines
13 KiB
Vala
376 lines
13 KiB
Vala
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
|
|
*
|
|
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
|
|
* @version : 0.5
|
|
* @type : library
|
|
* @date : 2018
|
|
* @licence : GPLv3.0 <http://www.gnu.org/licenses/>
|
|
* @author : a-Sansara <[dev]at[pluie]dot[org]>
|
|
* @copyright : pluie.org <http://www.pluie.org/>
|
|
*
|
|
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
|
|
*
|
|
* This file is part of pluie-yaml.
|
|
*
|
|
* pluie-yaml is free software (free as in speech) : you can redistribute it
|
|
* and/or modify it under the terms of the GNU General Public License as
|
|
* published by the Free Software Foundation, either version 3 of the License,
|
|
* or (at your option) any later version.
|
|
*
|
|
* pluie-yaml is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
|
* more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
|
|
*/
|
|
|
|
using GLib;
|
|
using Gee;
|
|
using Pluie;
|
|
|
|
/**
|
|
* a Yaml.Builder class helping to build vala Yaml.Object from Yaml.Node
|
|
*/
|
|
public class Pluie.Yaml.Builder
|
|
{
|
|
/**
|
|
*
|
|
*/
|
|
private static GLib.Module? p_module;
|
|
|
|
/**
|
|
*
|
|
*/
|
|
private static unowned GLib.Module p_open_module ()
|
|
{
|
|
if (p_module == null) {
|
|
p_module = GLib.Module.open (null, 0);
|
|
}
|
|
return p_module;
|
|
}
|
|
|
|
/**
|
|
*
|
|
*/
|
|
public static GLib.Type? type_from_string (string name)
|
|
{
|
|
GLib.Type? type = Type.from_name (name.replace(".", ""));
|
|
return type;
|
|
}
|
|
|
|
/**
|
|
* retriew GLib.Type related to specified vala name
|
|
* @param name a valid vala identifier name
|
|
*/
|
|
public static Type type_from_vala (string name)
|
|
{
|
|
void * s;
|
|
p_open_module ();
|
|
if (!p_module.symbol (resolve_c_name(@"$(name).get_type"), out s)) {
|
|
of.error ("cannot resolve type %s (not found)".printf (name));
|
|
}
|
|
return ((dlgType) s)();
|
|
}
|
|
|
|
/**
|
|
* retiew GLib.Type related to specified tag value.
|
|
* Type may not be registered yet
|
|
*/
|
|
public static Type? type_from_tag (string tagValue)
|
|
{
|
|
var type = type_from_string (tagValue);
|
|
if(type != null && type == Type.INVALID) {
|
|
type = type_from_vala (tagValue);
|
|
}
|
|
return type;
|
|
}
|
|
|
|
/**
|
|
* retriew corresponding c name related to specified vala name
|
|
* @param name a valid vala identifier name
|
|
*/
|
|
public static string resolve_c_name (string name)
|
|
{
|
|
string? str = null;
|
|
MatchInfo? mi = null;
|
|
StringBuilder sb = new StringBuilder ();
|
|
bool begin = true;
|
|
try {
|
|
var reg = new Regex ("([^.]*).?");
|
|
for (reg.match (name, 0, out mi) ; mi.matches () ; mi.next ()) {
|
|
if ((str = mi.fetch (1)) != null && str.length > 0) {
|
|
if (!begin) sb.append_unichar ('_');
|
|
else begin = false;
|
|
sb.append_unichar (str[0].tolower ());
|
|
sb.append (str.substring(1));
|
|
}
|
|
}
|
|
}
|
|
catch (GLib.RegexError e) {
|
|
of.error (e.message, true);
|
|
}
|
|
return !begin ? sb.str : name;
|
|
}
|
|
|
|
[CCode (has_target = false)]
|
|
private delegate Type dlgType();
|
|
|
|
/**
|
|
*
|
|
*/
|
|
public static Yaml.Object? from_node (Yaml.Node node, Type otype = GLib.Type.INVALID)
|
|
{
|
|
Yaml.Object? obj = null;
|
|
try {
|
|
Type type = node.tag != null ? type_from_tag (node.tag.value) : otype;
|
|
if (type != Type.INVALID) {
|
|
Yaml.dbg_action ("vala type founded", "%s (%s)".printf (type.name (), type.to_string ()));
|
|
if (type.is_object ()) {
|
|
obj = (Yaml.Object) GLib.Object.new (type);
|
|
obj.set ("yaml_name", node.name);
|
|
obj.yaml_construct ();
|
|
if (node!= null && !node.empty ()) {
|
|
GLib.ParamSpec? def = null;
|
|
Yaml.Node? scalar = null;
|
|
foreach (var child in node) {
|
|
if ((def = obj.get_class ().find_property (child.name)) != null) {
|
|
Yaml.dbg ("== prop [%s] type is : %s".printf (child.name, def.value_type.name ()));
|
|
if (child.ntype.is_single_pair () && (scalar = child.first ()) != null) {
|
|
set_from_scalar (ref obj, def.name, def.value_type, scalar.data);
|
|
}
|
|
else if (child.ntype.is_collection ()) {
|
|
set_from_collection (ref obj, type, child, def.value_type);
|
|
}
|
|
}
|
|
else {
|
|
of.warn ("property %s not found".printf (child.name));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (obj == null) {
|
|
of.warn ("searched type not found : %s".printf (type.name ()));
|
|
}
|
|
else {
|
|
obj.yaml_init ();
|
|
}
|
|
}
|
|
catch (GLib.Error e) {
|
|
of.warn (e.message);
|
|
}
|
|
return obj;
|
|
}
|
|
|
|
/**
|
|
*
|
|
*/
|
|
public static void set_from_collection (ref Yaml.Object obj, GLib.Type parentType, Yaml.Node node, GLib.Type type)
|
|
{
|
|
Yaml.dbg (" > set_from_collection %s (%s)".printf (node.name, type.name ()));
|
|
if (type.is_a (typeof (Yaml.Object))) {
|
|
obj.set (node.name, Yaml.Builder.from_node(node, type));
|
|
}
|
|
else if (type.is_a (typeof (Gee.ArrayList))) {
|
|
Yaml.GeeBuilder.arraylist_from_node(ref obj, node, type);
|
|
}
|
|
else if (Yaml.Object.register.is_registered_type(parentType, type)) {
|
|
Yaml.dbg ("%s is a registered type".printf (type.name ()));
|
|
obj.populate_from_node (type, node);
|
|
}
|
|
else {
|
|
Dbg.error ("%s is not registered and cannot be populated".printf (type.name ()), Log.METHOD, Log.LINE);
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
*/
|
|
public static void set_from_scalar (ref Yaml.Object obj, string name, GLib.Type type, string data)
|
|
{
|
|
GLib.Value v = GLib.Value(type);
|
|
Yaml.dbg_action ("Auto setting property value %s".printf (of.c (ECHO.MICROTIME).s (type.name ())), name);
|
|
Yaml.dbg (data);
|
|
if (type.is_a(Type.ENUM))
|
|
set_enum_value (ref v, type, data);
|
|
else
|
|
set_basic_type_value(ref v, type, data);
|
|
obj.set_property(name, v);
|
|
}
|
|
|
|
/**
|
|
*
|
|
*/
|
|
public static void set_basic_type_value (ref Value v, GLib.Type type, string data)
|
|
{
|
|
switch (type)
|
|
{
|
|
case Type.STRING :
|
|
v.set_string(data);
|
|
break;
|
|
case Type.CHAR :
|
|
v.set_schar((int8)data.data[0]);
|
|
break;
|
|
case Type.UCHAR :
|
|
v.set_uchar((uint8)data.data[0]);
|
|
break;
|
|
case Type.BOOLEAN :
|
|
v.set_boolean (data == "1" || data.down () == "true");
|
|
break;
|
|
case Type.INT :
|
|
v.set_int(int.parse(data));
|
|
break;
|
|
case Type.UINT :
|
|
v.set_uint((uint)long.parse(data));
|
|
break;
|
|
case Type.LONG :
|
|
case Type.INT64 :
|
|
v.set_long((long)int64.parse(data));
|
|
break;
|
|
case Type.ULONG :
|
|
case Type.UINT64 :
|
|
v.set_ulong((ulong)uint64.parse(data));
|
|
break;
|
|
case Type.FLOAT :
|
|
v.set_float((float)double.parse(data));
|
|
break;
|
|
case Type.DOUBLE :
|
|
v.set_double(double.parse(data));
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
*/
|
|
public static string? get_basic_type_value (GLib.Object obj, GLib.Type type, string name)
|
|
{
|
|
GLib.Value v = GLib.Value(Type.STRING);
|
|
switch (type)
|
|
{
|
|
case Type.STRING :
|
|
string s;
|
|
obj.get (name, out s);
|
|
v = s;
|
|
break;
|
|
case Type.CHAR :
|
|
char c;
|
|
obj.get (name, out c);
|
|
v = c.to_string ();
|
|
break;
|
|
case Type.UCHAR :
|
|
uchar c;
|
|
obj.get (name, out c);
|
|
break;
|
|
case Type.UINT64 :
|
|
case Type.UINT :
|
|
uint64 i;
|
|
obj.get (name, out i);
|
|
break;
|
|
case Type.INT64 :
|
|
case Type.INT :
|
|
int64 i;
|
|
obj.get (name, out i);
|
|
v = i.to_string ();
|
|
break;
|
|
case Type.BOOLEAN :
|
|
bool b;
|
|
obj.get (name, out b);
|
|
v = b.to_string ();
|
|
break;
|
|
case Type.DOUBLE :
|
|
double d;
|
|
obj.get (name, out d);
|
|
v = "%f".printf (d);
|
|
break;
|
|
case Type.FLOAT :
|
|
float f;
|
|
obj.get (name, out f);
|
|
v = "%f".printf (f);
|
|
break;
|
|
}
|
|
return (string) v;
|
|
}
|
|
|
|
/**
|
|
*
|
|
*/
|
|
public static void set_enum_value (ref Value v, GLib.Type type, string data)
|
|
{
|
|
EnumClass kenum = (EnumClass) type.class_ref();
|
|
unowned EnumValue? enumval = kenum.get_value_by_name(data);
|
|
if (enumval == null) {
|
|
enumval = kenum.get_value_by_nick(data.down());
|
|
int64 e = 0;
|
|
if(enumval == null) {
|
|
if(!int64.try_parse(data, out e)) {
|
|
Dbg.error ("invalid enum value %s".printf(data), Log.METHOD, Log.LINE);
|
|
}
|
|
else enumval = kenum.get_value((int)e);
|
|
}
|
|
}
|
|
v.set_enum(enumval.value);
|
|
//~ of.echo ("enumValue : %d".printf (enumval.value));
|
|
}
|
|
|
|
public static string transform_param_name (string name)
|
|
{
|
|
return name.replace("-", "_");
|
|
}
|
|
|
|
/**
|
|
*
|
|
*/
|
|
public static Yaml.Node to_node (Yaml.Object obj, Yaml.Node? parent = null, bool root = true)
|
|
{
|
|
var node = new Yaml.Mapping (parent, obj.yaml_name);
|
|
string? name = null;
|
|
foreach (var def in obj.get_class ().list_properties ()){
|
|
name = Yaml.Builder.transform_param_name(def.name);
|
|
if (name != null && name != "yaml_name") {
|
|
if (def.value_type.is_a (typeof (Gee.ArrayList))) {
|
|
void *p;
|
|
obj.get(name, out p);
|
|
Yaml.GeeBuilder.arraylist_to_node(p, name, node);
|
|
}
|
|
else if (def.value_type.is_a (typeof (Yaml.Object)) || Yaml.Object.register.is_registered_type(obj.get_type (), def.value_type)) {
|
|
var child = obj.populate_to_node(def.value_type, name);
|
|
if (child != null) {
|
|
child.tag = new Yaml.Tag (Yaml.Object.register.resolve_namespace_type(def.value_type), "v");
|
|
node.add (child);
|
|
}
|
|
}
|
|
else if (def.value_type.is_enum ()) {
|
|
EnumValue enumval;
|
|
obj.get (name, out enumval);
|
|
string data = enumval.value.to_string ();
|
|
var n = new Yaml.Mapping.with_scalar (node, name, (string) data);
|
|
n.tag = new Yaml.Tag (Yaml.Object.register.resolve_namespace_type(def.value_type), "v");
|
|
|
|
}
|
|
else if (def.value_type.is_fundamental ()) {
|
|
string data = Yaml.Builder.get_basic_type_value(obj, def.value_type, name);
|
|
if (data != null) {
|
|
new Yaml.Mapping.with_scalar (node, name, (string) data);
|
|
}
|
|
}
|
|
else {
|
|
of.error ("type %s for property %s is not registered".printf (def.value_type.name (), name));
|
|
}
|
|
}
|
|
}
|
|
node.tag = new Yaml.Tag (Yaml.Object.register.resolve_namespace_type(obj.get_type ()), "v");
|
|
if (root) {
|
|
var rootNode = new Yaml.Root();
|
|
rootNode.add (node);
|
|
rootNode.tag_directives["!v!"] = "tag:pluie.org,2018:vala/";
|
|
return rootNode;
|
|
}
|
|
else return node;
|
|
}
|
|
}
|