private void FillFields(Type tType, object result, OMCLObject obj)
{
var fields = tType.GetFields(BindingFlags.Public | BindingFlags.Instance);
var props = tType.GetProperties(BindingFlags.Public | BindingFlags.Instance);
foreach (var field in fields)
{
var name = field.Name;
if (!obj.HasProperty(name))
{
continue;
}
var value = obj[name];
SetField(field, result, value);
obj.RemoveProperty(name);
}
foreach (var prop in props)
{
var name = prop.Name;
if (!obj.HasProperty(name))
{
continue;
}
var value = obj[name];
SetField(prop, result, value);
obj.RemoveProperty(name);
}
if (!obj.Empty)
{
var sb = new StringBuilder();
var ser = Serializer.ToStringBuilder(sb);
ser.Serialize(obj);
throw new Exception($"Failed to deserialize object into type '{tType.FullName}'. There are unknown properties:\n{sb}");
}
}
private object ConvertObject(Type type, List <string> tags, OMCLObject obj)
{
// check for custom converters
if (_objectConverters.ContainsKey(type))
{
var conv = _objectConverters[type];
if (conv.CanConvert(tags, obj))
{
var instance = conv.CreateInstance(tags);
var instanceType = instance.GetType();
FillFields(instanceType, instance, obj);
return(instance);
}
}
// check if its a dictionary
var iDictionary = type.GetInterfaces().Where(t => {
return(t.Name.StartsWith(nameof(IDictionary) + "`") &&
t.GenericTypeArguments.Length == 2 &&
t.GenericTypeArguments[0] == typeof(string));
}).FirstOrDefault();
if (iDictionary != null)
{
var keyType = iDictionary.GenericTypeArguments[0];
var valueType = iDictionary.GenericTypeArguments[1];
var col = Activator.CreateInstance(type);
var addMethod = col.GetType().GetMethod("Add", new Type[] { keyType, valueType });
foreach (var(key, item) in obj)
{
var value = ConvertItemToValue(valueType, item);
addMethod.Invoke(col, new object[] { key, value });
}
return(col);
}
var result = Activator.CreateInstance(type);
FillFields(type, result, obj);
return(result);
}
public void Write(OMCLObject obj)
{
_writer.Write("{");
if (obj.Empty)
{
_writer.WriteLine("}");
return;
}
_writer.WriteLine();
foreach (var(key, val) in obj)
{
Indent(1);
if (PropNameNeedsQuotation(key))
{
_writer.Write('"');
_writer.Write(key);
_writer.Write('"');
}
else
{
_writer.Write(key);
}
if (val.Type == OMCLItem.OMCLItemType.Object || val.Type == OMCLItem.OMCLItemType.Array)
{
_writer.Write(" ");
}
else
{
_writer.Write(" = ");
}
WriteValue(val);
}
Indent();
_writer.WriteLine("}");
}
private void FillFields <T>(T result, OMCLObject obj)
{
FillFields(typeof(T), result, obj);
}
public OMCLItem(OMCLObject item)
{
_value = item;
Type = OMCLItemType.Object;
}
public void Add(OMCLObject item)
{
Add(new OMCLItem(item));
}
private OMCLObject DoParseObject(params TokenType[] delimiters)
{
OMCLObject resultObject = new OMCLObject();
SkipNewlines();
var next = PeekToken();
if (delimiters.Any(d => (d == next.Type)))
{
return(resultObject);
}
while (true)
{
string key = null;
if (next.Type != TokenType.String && next.Type != TokenType.Identifier)
{
ReportError("Failed to parse property. Expected property name (string or identifier)");
return(null);
}
key = next.value as string;
NextToken();
SkipNewlines();
next = PeekToken();
if (!(next.Type == TokenType.OpenBrace || next.Type == TokenType.OpenBracket))
{
if (!Expect(TokenType.Equals))
{
ReportError("Failed to parse property. Expected '='");
}
SkipNewlines();
}
var item = ParseItem();
resultObject.Add(key, item);
bool nl = SkipNewlines();
next = PeekToken();
if (delimiters.Any(d => (d == next.Type)))
{
break;
}
else if (next.Type == TokenType.Comma)
{
NextToken();
SkipNewlines();
next = PeekToken();
if (delimiters.Any(d => (d == next.Type)))
{
break;
}
}
else if (!nl)
{
ReportError("Failed to parse object. Expected '\\n' or ',' after property");
}
}
return(resultObject);
}
