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 void PathTest()
{
var json = @"
{
""a"": [
{
""aa"": 1
}
]
}
";
var root = JsonParser.Parse(json);
{
var it = root.Traverse().GetEnumerator();
it.MoveNext(); Assert.AreEqual("/", it.Current.Pointer().ToString());
it.MoveNext(); Assert.AreEqual("/a", it.Current.Pointer().ToString());
it.MoveNext(); Assert.AreEqual("/a/0", it.Current.Pointer().ToString());
it.MoveNext(); Assert.AreEqual("/a/0/aa", it.Current.Pointer().ToString());
Assert.False(it.MoveNext());
}
{
var it = root.Traverse().GetEnumerator();
var f = new JsonFormatter();
f.Value("JsonPath");
root.SetValue(Utf8String.From("/a"), f.GetStoreBytes());
it.MoveNext(); Assert.AreEqual("/", it.Current.Pointer().ToString());
it.MoveNext(); Assert.AreEqual("/a", it.Current.Pointer().ToString());
Assert.False(it.MoveNext());
}
}
public ListTreeNode <T> this[String key]
{
get
{
return(this[Utf8String.From(key)]);
}
}
public void SplitIntegerTest()
{
Assert.AreEqual("1", Utf8String.From("1 ").SplitInteger().ToString());
Assert.AreEqual("123", Utf8String.From("123").SplitInteger().ToString());
Assert.Catch(() => Utf8String.From(" 1").SplitInteger());
Assert.AreEqual("+12", Utf8String.From("+12\n").SplitInteger().ToString());
Assert.AreEqual("-123", Utf8String.From("-123\n").SplitInteger().ToString());
}
public void MinusInfinityTest()
{
{
var v = new JsonValue(Utf8String.From("-Infinity"), ValueNodeType.MinusInfinity, -1);
Assert.AreEqual("-Infinity", v.ToString());
Assert.AreEqual(Double.NegativeInfinity, v.GetDouble());
}
}
public void NaNTest()
{
{
var v = new JsonValue(Utf8String.From("NaN"), ValueNodeType.NaN, -1);
Assert.AreEqual("NaN", v.ToString());
Assert.AreEqual(Double.NaN, v.GetDouble());
}
}
public void InfinityTest()
{
{
var v = new JsonValue(Utf8String.From("Infinity"), ValueNodeType.Infinity, -1);
Assert.AreEqual("Infinity", v.ToString());
Assert.AreEqual(Double.PositiveInfinity, v.GetValue <double>());
}
}
public static void Deserialize(ListTreeNode <S> src, ref T dst, Dictionary <string, JsonSchema> props)
{
if (s_d == null)
{
var target = typeof(T);
var fields = target.GetFields(BindingFlags.Instance | BindingFlags.Public);
var fieldDeserializers = fields.ToDictionary(x => Utf8String.From(x.Name), x =>
{
/*
* var mi = typeof(GenericDeserializer<T>).GetMethod("GetFieldDeserializer",
* BindingFlags.Static | BindingFlags.NonPublic);
* var g = mi.MakeGenericMethod(x.FieldType);
* return (FieldSetter)g.Invoke(null, new object[] { x });
*/
JsonSchema prop;
if (!props.TryGetValue(x.Name, out prop))
{
return(null);
}
var mi = typeof(GenericDeserializer <S, T>).GetMethod("DeserializeField",
BindingFlags.Static | BindingFlags.NonPublic);
var g = mi.MakeGenericMethod(x.FieldType);
return((FieldSetter)((s, o) =>
{
var f = g.Invoke(null, new object[] { prop, s });
x.SetValue(o, f);
}));
});
s_d = (ListTreeNode <S> s) =>
{
if (!s.IsMap())
{
throw new ArgumentException(s.Value.ValueType.ToString());
}
// boxing
var t = (object)Activator.CreateInstance <T>();
foreach (var kv in s.ObjectItems())
{
FieldSetter setter;
if (fieldDeserializers.TryGetValue(kv.Key.GetUtf8String(), out setter))
{
if (setter != null)
{
setter(kv.Value, t);
}
}
}
return((T)t);
};
}
dst = s_d(src);
}
public void QuoteTest()
{
{
var value = Utf8String.From("ho５日本語ge");
var quoted = Utf8String.From("\"ho５日本語ge\"");
Assert.AreEqual(quoted, JsonString.Quote(value));
Assert.AreEqual(value, JsonString.Unquote(quoted));
}
{
var value = Utf8String.From("fuga\n ho５日本語ge");
var quoted = Utf8String.From("\"fuga\\n ho５日本語ge\"");
Assert.AreEqual(quoted, JsonString.Quote(value));
Assert.AreEqual(value, JsonString.Unquote(quoted));
}
}
static Utf8String GetKeyFromParent(JsonNode json)
{
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();
}
}
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 void SplitTest()
{
{
var value = Utf8String.From("a/５/c");
var split = value.Split((byte)'/').ToArray();
Assert.AreEqual(3, split.Length);
Assert.AreEqual(split[0], Utf8String.From("a"));
Assert.AreEqual(split[1], Utf8String.From("５"));
Assert.AreEqual(split[2], Utf8String.From("c"));
}
{
var value = Utf8String.From("/a/５/c/");
var split = value.Split((byte)'/').ToArray();
Assert.AreEqual(4, split.Length);
Assert.AreEqual(split[0], Utf8String.From(""));
Assert.AreEqual(split[1], Utf8String.From("a"));
Assert.AreEqual(split[2], Utf8String.From("５"));
Assert.AreEqual(split[3], Utf8String.From("c"));
}
}
public void ToCharTest()
{
{
// 1byte
var c = 'A';
Assert.AreEqual(1, Utf8String.From(c.ToString()).GetFirst().CurrentByteLength);
Assert.AreEqual(c, Utf8String.From(c.ToString()).GetFirst().Unicode);
Assert.AreEqual(c, Utf8String.From(c.ToString()).GetFirst().Char);
}
{
// 2byte
var c = '¢';
Assert.AreEqual(2, Utf8String.From(c.ToString()).GetFirst().CurrentByteLength);
Assert.AreEqual(c, Utf8String.From(c.ToString()).GetFirst().Unicode);
Assert.AreEqual(c, Utf8String.From(c.ToString()).GetFirst().Char);
}
{
// 3byte
var c = '５';
Assert.AreEqual(3, Utf8String.From(c.ToString()).GetFirst().CurrentByteLength);
Assert.AreEqual(c, Utf8String.From(c.ToString()).GetFirst().Unicode);
Assert.AreEqual(c, Utf8String.From(c.ToString()).GetFirst().Char);
}
{
var c = '仡';
Assert.AreEqual(3, Utf8String.From(c.ToString()).GetFirst().CurrentByteLength);
Assert.AreEqual(c, Utf8String.From(c.ToString()).GetFirst().Unicode);
Assert.AreEqual(c, Utf8String.From(c.ToString()).GetFirst().Char);
}
{
// emoji
var s = "😃";
Assert.AreEqual(4, Utf8String.From(s).GetFirst().CurrentByteLength);
Assert.AreEqual(0x1F603, Utf8String.From(s).GetFirst().Unicode);
Assert.Catch(() =>
{
var a = Utf8String.From(s).GetFirst().Char;
});
}
}
public void FromStringTest()
{
var buffer = new byte[12];
{
var src = "abc";
var utf8 = Utf8String.From(src, buffer);
Assert.AreEqual(3, utf8.ByteLength);
Assert.AreEqual(src, utf8.ToString());
}
{
var src = "¢";
var utf8 = Utf8String.From(src, buffer);
Assert.AreEqual(2, utf8.ByteLength);
Assert.AreEqual(src, utf8.ToString());
}
{
var src = "５";
var utf8 = Utf8String.From(src, buffer);
Assert.AreEqual(3, utf8.ByteLength);
Assert.AreEqual(src, utf8.ToString());
}
}
public void Utf8StringTest()
{
var abc = Utf8String.From("abc");
var ab = Utf8String.From("ab");
var bc = Utf8String.From("bc");
Assert.True(abc.StartsWith(ab));
Assert.False(ab.StartsWith(abc));
Assert.True(abc.EndsWith(bc));
Assert.False(bc.EndsWith(abc));
Assert.AreEqual(Utf8String.From("abbc"), ab.Concat(bc));
Assert.AreEqual(2, abc.IndexOf((byte)'c'));
int pos;
abc.TrySearchAscii((byte)'c', 0, out pos);
Assert.AreEqual(2, pos);
abc.TrySearchAscii((byte)'c', 1, out pos);
Assert.AreEqual(2, pos);
}
public static ListTreeNode <TomlValue> Parse(String Toml)
{
return(Parse(Utf8String.From(Toml)));
}
public static JsonNode Parse(String json)
{
return(Parse(Utf8String.From(json)));
}
static Func <ListTreeNode <T>, U> GetDeserializer()
{
// primitive
{
var mi = typeof(ListTreeNode <T>).GetMethods().FirstOrDefault(x =>
{
if (!x.Name.StartsWith("Get"))
{
return(false);
}
if (!x.Name.EndsWith(typeof(U).Name))
{
return(false);
}
var parameters = x.GetParameters();
if (parameters.Length != 0)
{
return(false);
}
if (x.ReturnType != typeof(U))
{
return(false);
}
return(true);
});
if (mi != null)
{
var self = Expression.Parameter(typeof(ListTreeNode <T>), "self");
var call = Expression.Call(self, mi);
var func = Expression.Lambda(call, self);
return((Func <ListTreeNode <T>, U>)func.Compile());
}
}
var target = typeof(U);
if (target.IsArray)
{
var mi = typeof(GenericDeserializer <T, U>).GetMethod("GenericArrayDeserializer",
BindingFlags.Static | BindingFlags.NonPublic);
var g = mi.MakeGenericMethod(target.GetElementType());
var self = Expression.Parameter(typeof(ListTreeNode <T>), "self");
var call = Expression.Call(g, self);
var func = Expression.Lambda(call, self);
return((Func <ListTreeNode <T>, U>)func.Compile());
}
if (target.IsGenericType)
{
if (target.GetGenericTypeDefinition() == typeof(List <>))
{
var mi = typeof(GenericDeserializer <T, U>).GetMethod("GenericListDeserializer",
BindingFlags.Static | BindingFlags.NonPublic);
var g = mi.MakeGenericMethod(target.GetGenericArguments());
var self = Expression.Parameter(typeof(ListTreeNode <T>), "self");
var call = Expression.Call(g, self);
var func = Expression.Lambda(call, self);
return((Func <ListTreeNode <T>, U>)func.Compile());
}
if (target.GetGenericTypeDefinition() == typeof(Dictionary <,>) &&
target.GetGenericArguments()[0] == typeof(string))
{
var mi = typeof(ListTreeNodeDeserializerExtensions).GetMethod("DictionaryDeserializer",
BindingFlags.Static | BindingFlags.NonPublic);
var g = mi.MakeGenericMethod(typeof(T));
var self = Expression.Parameter(typeof(ListTreeNode <T>), "self");
var call = Expression.Call(g, self);
var func = Expression.Lambda(call, self);
var d = (Func <ListTreeNode <T>, object>)func.Compile();
return((ListTreeNode <T> s) =>
{
var x = d(s);
return (U)x;
});
}
}
{
var schema = JsonSchema.FromType <U>();
return(s =>
{
var t = default(U);
schema.Validator.Deserialize(s, ref t);
return t;
});
}
#if false
if (target.IsEnum)
{
var value = Expression.Parameter(typeof(int), "value");
var cast = Expression.Convert(value, target);
var func = Expression.Lambda(cast, value);
var compiled = (Func <int, T>)func.Compile();
return(s =>
{
return compiled(s.GetInt32());
});
}
{
var fields = target.GetFields(BindingFlags.Instance | BindingFlags.Public);
var fieldDeserializers = fields.ToDictionary(x => Utf8String.From(x.Name), x =>
{
var mi = typeof(GenericDeserializer <S, T>).GetMethod("GetFieldDeserializer",
BindingFlags.Static | BindingFlags.NonPublic);
var g = mi.MakeGenericMethod(x.FieldType);
return((FieldSetter)g.Invoke(null, new object[] { x }));
});
return((S s) =>
{
if (!s.IsMap())
{
throw new ArgumentException(s.ValueType.ToString());
}
var t = (object)default(GenericCreator <S, T>).Create(s);
foreach (var kv in s.ObjectItems())
{
FieldSetter setter;
if (fieldDeserializers.TryGetValue(kv.Key, out setter))
{
setter(kv.Value, t);
}
}
return (T)t;
});
}
#endif
}
public void AtoiTest()
{
Assert.AreEqual(1234, Utf8String.From("1234").ToInt32());
}
public static int Unescape(Utf8String s, IStore w)
{
int writeCount = 0;
Action <Byte> Write = c =>
{
if (w != null)
{
w.Write(c);
}
++writeCount;
};
var it = s.GetIterator();
while (it.MoveNext())
{
var l = it.CurrentByteLength;
if (l == 1)
{
if (it.Current == (Byte)'\\')
{
var c = it.Second;
switch (c)
{
case (Byte)'\\':
case (Byte)'/':
case (Byte)'"':
// remove prefix
Write(c);
it.MoveNext();
continue;
case (Byte)'b':
Write((Byte)'\b');
it.MoveNext();
continue;
case (Byte)'f':
Write((Byte)'\f');
it.MoveNext();
continue;
case (Byte)'n':
Write((Byte)'\n');
it.MoveNext();
continue;
case (Byte)'r':
Write((Byte)'\r');
it.MoveNext();
continue;
case (Byte)'t':
Write((Byte)'\t');
it.MoveNext();
continue;
case (Byte)'u':
{
// skip back slash
it.MoveNext();
// skip u
it.MoveNext();
var u0 = CheckHex((char)it.Current);
it.MoveNext();
var u1 = CheckHex((char)it.Current);
it.MoveNext();
var u2 = CheckHex((char)it.Current);
it.MoveNext();
var u3 = CheckHex((char)it.Current);
var u = (u0 << 12) + (u1 << 8) + (u2 << 4) + u3;
var utf8 = Utf8String.From(new string(new char[] { (char)u }));
// var utf8 = Utf8String.From((int)u);
foreach (var x in utf8.Bytes)
{
Write(x);
}
}
continue;
}
}
Write(it.Current);
}
else if (l == 2)
{
Write(it.Current);
Write(it.Second);
}
else if (l == 3)
{
Write(it.Current);
Write(it.Second);
Write(it.Third);
}
else if (l == 4)
{
Write(it.Current);
Write(it.Second);
Write(it.Third);
Write(it.Fourth);
}
else
{
throw new ParserException("invalid utf8");
}
}
return(writeCount);
}
public static JsonNode GetObjectItem(this JsonNode self, String key)
{
return(self.GetObjectItem(Utf8String.From(key)));
}
public void Value(string x)
{
Value(Utf8String.From(x));
}
public static bool ContainsKey(this JsonNode self, String key)
{
var ukey = Utf8String.From(key);
return(self.ContainsKey(ukey));
}
public static bool TryGet(this JsonNode self, String key, out JsonNode found)
{
var ukey = Utf8String.From(key);
return(self.TryGet(ukey, out found));
}
public void Value(String s)
{
Value(Utf8String.From(s));
}
public static ListTreeNode <JsonValue> Parse(String json)
{
return(Parse(Utf8String.From(json)));
}
public static void Key(this IFormatter f, string x)
{
f.Key(Utf8String.From(x));
}
public static ListTreeNode <T> GetObjectItem <T>(this ListTreeNode <T> self, String key)
where T : IListTreeItem, IValue <T>
{
return(self.GetObjectItem(Utf8String.From(key)));
}
