public static object DefaultDictionaryDeserializer(ListTreeNode <T> s)
{
switch (s.Value.ValueType)
{
case ValueNodeType.Object:
{
var u = new Dictionary <string, object>();
foreach (var kv in s.ObjectItems())
{
//var e = default(object);
//kv.Value.Deserialize(ref e);
u.Add(kv.Key.GetString(), DefaultDictionaryDeserializer(kv.Value));
}
return(u);
}
case ValueNodeType.Null:
return(null);
case ValueNodeType.Boolean:
return(s.GetBoolean());
case ValueNodeType.Integer:
return(s.GetInt32());
case ValueNodeType.Number:
return(s.GetDouble());
case ValueNodeType.String:
return(s.GetString());
default:
throw new NotImplementedException(s.Value.ValueType.ToString());
}
}
public static IEnumerable <ListTreeNode <T> > Traverse <T>(this ListTreeNode <T> self) where T : IListTreeItem, IValue <T>
{
yield return(self);
if (self.IsArray())
{
foreach (var x in self.ArrayItems())
{
foreach (var y in x.Traverse())
{
yield return(y);
}
}
}
else if (self.IsMap())
{
foreach (var kv in self.ObjectItems())
{
foreach (var y in kv.Value.Traverse())
{
yield return(y);
}
}
}
}
public static bool IsFloat <T>(this ListTreeNode <T> self) where T : IListTreeItem, IValue <T>
{
return(self.Value.ValueType == ValueNodeType.Number ||
self.Value.ValueType == ValueNodeType.NaN ||
self.Value.ValueType == ValueNodeType.Infinity ||
self.Value.ValueType == ValueNodeType.MinusInfinity);
}
public static bool ContainsKey <T>(this ListTreeNode <T> self, String key)
where T : IListTreeItem, IValue <T>
{
var ukey = Utf8String.From(key);
return(self.ContainsKey(ukey));
}
public static JsonPointer Create <T>(ListTreeNode <T> node)
where T : IListTreeItem, IValue <T>
{
return(new JsonPointer
{
Path = new ArraySegment <Utf8String>(node.Path().Skip(1).Select(x => GetKeyFromParent(x)).ToArray())
});
}
public static IEnumerable <ListTreeNode <T> > ArrayItems <T>(this ListTreeNode <T> self) where T : IListTreeItem, IValue <T>
{
if (!self.IsArray())
{
throw new DeserializationException("is not array");
}
return(self.Children);
}
public static int GetObjectCount <T>(this ListTreeNode <T> self)
where T : IListTreeItem, IValue <T>
{
if (!self.IsMap())
{
throw new DeserializationException("is not object");
}
return(self.Children.Count() / 2);
}
public static int GetArrayCount <T>(this ListTreeNode <T> self)
where T : IListTreeItem, IValue <T>
{
if (!self.IsArray())
{
throw new DeserializationException("is not array");
}
return(self.Children.Count());
}
public static void Deserialize(ListTreeNode <T> node, ref U value)
{
if (s_deserializer == null)
{
var d = GetDeserializer();
s_deserializer = new Deserializer(d);
}
value = s_deserializer(node);
}
public U Create(ListTreeNode <T> src)
{
if (s_creator == null)
{
var d = GetCreator();
s_creator = new Creator(d);
}
return(s_creator(src));
}
public static JsonDiff Create <T>(ListTreeNode <T> node, JsonDiffType diffType, string msg)
where T : IListTreeItem, IValue <T>
{
return(new JsonDiff
{
Path = JsonPointer.Create(node),
DiffType = diffType,
Msg = msg,
});
}
static V[] ArrayCreator <V>(ListTreeNode <T> src)
{
if (!src.IsArray())
{
throw new ArgumentException("value is not array");
}
var count = src.GetArrayCount();
return(new V[count]);
}
public void Call(IRpc f, int id, string method, ListTreeNode <T> args)
{
Callback callback;
if (!m_map.TryGetValue(method, out callback))
{
throw new KeyNotFoundException();
}
callback(id, args, f);
}
public static void SetValue <T>(this ListTreeNode <T> self,
Utf8String jsonPointer, ArraySegment <Byte> bytes)
where T : IListTreeItem, IValue <T>
{
foreach (var node in self.GetNodes(jsonPointer))
{
node.SetValue(default(T).New(
bytes,
ValueNodeType.Boolean,
node.Value.ParentIndex));
}
}
public static Utf8String KeyOf <T>(this ListTreeNode <T> self, ListTreeNode <T> node)
where T : IListTreeItem, IValue <T>
{
foreach (var kv in self.ObjectItems())
{
if (node.ValueIndex == kv.Value.ValueIndex)
{
return(kv.Key.GetUtf8String());
}
}
throw new KeyNotFoundException();
}
public static IEnumerable <ListTreeNode <T> > Path <T>(this ListTreeNode <T> self)
where T : IListTreeItem, IValue <T>
{
if (self.HasParent)
{
foreach (var x in self.Parent.Path())
{
yield return(x);
}
}
yield return(self);
}
public static void RemoveValue <T>(this ListTreeNode <T> self, Utf8String jsonPointer)
where T : IListTreeItem, IValue <T>
{
foreach (var node in self.GetNodes(new JsonPointer(jsonPointer)))
{
if (node.Parent.IsMap())
{
node.Prev.SetValue(default(T)); // remove key
}
node.SetValue(default(T)); // remove
}
}
public static ListTreeNode <T> GetObjectItem <T>(this ListTreeNode <T> self, Utf8String key)
where T : IListTreeItem, IValue <T>
{
foreach (var kv in self.ObjectItems())
{
if (kv.Key.GetUtf8String() == key)
{
return(kv.Value);
}
}
throw new KeyNotFoundException();
}
static ListTreeNode <JsonValue> ParseString(ListTreeNode <JsonValue> tree, Utf8String segment)
{
int pos;
if (segment.TrySearchAscii((Byte)'"', 1, out pos))
{
return(tree.AddValue(segment.Subbytes(0, pos + 1).Bytes, ValueNodeType.String));
}
else
{
throw new ParserException("no close string: " + segment);
}
}
/// <summary>
/// Deserialize Dictionary only string key
/// </summary>
/// <typeparam name="V"></typeparam>
/// <param name="s"></param>
/// <returns></returns>
public static Dictionary <string, V> DictionaryDeserializer <V>(ListTreeNode <T> s)
{
var d = new Dictionary <string, V>();
foreach (var kv in s.ObjectItems())
{
var value = default(V);
GenericDeserializer <T, V> .Deserialize(kv.Value, ref value);
d.Add(kv.Key.GetString(), value);
}
return(d);
}
public static Nullable <V> GenericNullableDeserializer <V>(ListTreeNode <T> parsed) where V : struct
{
if (!parsed.IsNull())
{
var c = default(V);
parsed.Deserialize(ref c);
return(c);
}
else
{
return(default(V));
}
}
static ListTreeNode <MsgPackValue> _Parse(ListTreeNode <MsgPackValue> tree, ArraySegment <Byte> bytes)
{
MsgPackType formatType = GetFormat(bytes);
if (formatType.IsArray())
{
var array = tree.AddValue(bytes, ValueNodeType.Array);
uint count;
bytes = GetItemCount(bytes, formatType, out count);
for (var i = 0; i < count; ++i)
{
var child = _Parse(array, bytes);
bytes = bytes.Advance(child.Value.Bytes.Count);
}
array.SetValueBytesCount(bytes.Offset - array.Value.Bytes.Offset);
return(array);
}
else if (formatType.IsMap())
{
var obj = tree.AddValue(bytes, ValueNodeType.Object);
uint count;
bytes = GetItemCount(bytes, formatType, out count);
for (var i = 0; i < count; ++i)
{
// key
var key = _Parse(obj, bytes);
bytes = bytes.Advance(key.Value.Bytes.Count);
// value
var value = _Parse(obj, bytes);
bytes = bytes.Advance(value.Value.Bytes.Count);
}
obj.SetValueBytesCount(bytes.Offset - obj.Value.Bytes.Offset);
return(obj);
}
else
{
var body = GetBody(bytes, formatType);
var headerSize = body.Offset - bytes.Offset;
var size = headerSize + body.Count;
var value = tree.AddValue(bytes.Take(size), ValueNodeType.Null);
return(value);
}
}
public static ListTreeNode <T> GetArrrayItem <T>(this ListTreeNode <T> self, int index)
where T : IListTreeItem, IValue <T>
{
int i = 0;
foreach (var v in self.ArrayItems())
{
if (i++ == index)
{
return(v);
}
}
throw new KeyNotFoundException();
}
public static V[] GenericArrayDeserializer <V>(ListTreeNode <T> s)
{
if (!s.IsArray())
{
throw new ArgumentException("not array: " + s.Value.ValueType);
}
var u = new V[s.GetArrayCount()];
int i = 0;
foreach (var x in s.ArrayItems())
{
x.Deserialize(ref u[i++]);
}
return(u);
}
public static int IndexOf <T>(this ListTreeNode <T> self, ListTreeNode <T> child)
where T : IListTreeItem, IValue <T>
{
int i = 0;
foreach (var v in self.ArrayItems())
{
if (v.ValueIndex == child.ValueIndex)
{
return(i);
}
++i;
}
throw new KeyNotFoundException();
}
public static List <V> GenericListDeserializer <V>(ListTreeNode <T> s)
{
if (!s.IsArray())
{
throw new ArgumentException("not array: " + s.Value.ValueType);
}
var u = new List <V>(s.GetArrayCount());
foreach (var x in s.ArrayItems())
{
var e = default(V);
x.Deserialize(ref e);
u.Add(e);
}
return(u);
}
/// <summary>
/// Expected null, boolean, integer, number
/// </summary>
/// <param name="segment"></param>
/// <param name="valueType"></param>
/// <param name="parentIndex"></param>
/// <returns></returns>
static ListTreeNode <JsonValue> ParsePrimitive(ListTreeNode <JsonValue> tree, Utf8String segment, ValueNodeType valueType)
{
int i = 1;
for (; i < segment.ByteLength; ++i)
{
if (Char.IsWhiteSpace((char)segment[i]) ||
segment[i] == '}' ||
segment[i] == ']' ||
segment[i] == ',' ||
segment[i] == ':'
)
{
break;
}
}
return(tree.AddValue(segment.Subbytes(0, i).Bytes, valueType));
}
static Utf8String GetKeyFromParent <T>(ListTreeNode <T> json)
where T : IListTreeItem, IValue <T>
{
var parent = json.Parent;
if (parent.IsArray())
{
var index = parent.IndexOf(json);
return(Utf8String.From(index));
}
else if (parent.IsMap())
{
return(parent.KeyOf(json));
}
else
{
throw new NotImplementedException();
}
}
public static ListTreeNode <JsonValue> Parse(ListTreeNode <JsonValue> tree, Utf8String segment)
{
// skip white space
int pos;
if (!segment.TrySearchByte(x => !char.IsWhiteSpace((char)x), out pos))
{
throw new ParserException("only whitespace");
}
segment = segment.Subbytes(pos);
var valueType = GetValueType(segment);
switch (valueType)
{
case ValueNodeType.Boolean:
case ValueNodeType.Integer:
case ValueNodeType.Number:
case ValueNodeType.Null:
case ValueNodeType.NaN:
case ValueNodeType.Infinity:
case ValueNodeType.MinusInfinity:
return(ParsePrimitive(tree, segment, valueType));
case ValueNodeType.String:
return(ParseString(tree, segment));
case ValueNodeType.Array: // fall through
return(ParseArray(tree, segment));
case ValueNodeType.Object: // fall through
return(ParseObject(tree, segment));
default:
throw new NotImplementedException();
}
}
public static IEnumerable <KeyValuePair <ListTreeNode <T>, ListTreeNode <T> > > ObjectItems <T>(this ListTreeNode <T> self)
where T : IListTreeItem, IValue <T>
{
if (!self.IsMap())
{
throw new DeserializationException("is not object");
}
var it = self.Children.GetEnumerator();
while (it.MoveNext())
{
var key = it.Current;
it.MoveNext();
yield return(new KeyValuePair <ListTreeNode <T>, ListTreeNode <T> >(key, it.Current));
}
}