protected static object ConvertObject(object value, TypeInfo typeInfo, bool nullable)
{
if (typeInfo == null)
{
value = null;
}
else if (value != null)
{
if (typeInfo.Type != typeof(object) && !typeInfo.Type.IsAssignableFrom(value.GetType()))
{
if (typeInfo.IsArray)
{
TypeInfo valueTypeInfo = typeInfo.TypeCache.GetTypeInfo(value.GetType());
value = valueTypeInfo.ToArray(value) ?? MemberInfo.CreateArray(value, typeInfo);
}
else if (value is IConvertible valueConvert)
{
value = valueConvert.ToType(typeInfo.Type, CultureInfo.InvariantCulture);
}
else
{
throw JsonException.New(Resources.Convert_TypeFailed, value, typeInfo.Type.FullName);
}
}
}
else if (typeInfo.IsValueType && !nullable)
{
throw JsonException.New(Resources.Convert_TypeFailed, "null", typeInfo.Type.FullName);
}
return(value);
}
public PropertyInfo(TypeInfo typeInfo, System.Reflection.PropertyInfo info)
: base(typeInfo, info, null, typeInfo.TypeCache.GetTypeInfo(info.PropertyType))
{
this.callGet = new Lazy <Func <object, object> >(() =>
{
ParameterExpression targetParam = Expression.Parameter(typeof(object), null);
Expression castTarget = ReflectionUtility.Convert(targetParam, typeInfo);
MemberExpression propertyAccess = Expression.MakeMemberAccess(castTarget, info);
Expression castProperty = Expression.Convert(propertyAccess, typeof(object));
return(ReflectionUtility.CompileLambda <Func <object, object> >(castProperty, targetParam));
});
this.callSet = new Lazy <Action <object, object> >(() =>
{
System.Reflection.MethodInfo setMethod = info.GetSetMethod(nonPublic: true);
if (setMethod == null)
{
throw JsonException.New(Resources.Convert_NoSetter, info.Name, info.DeclaringType.FullName);
}
ParameterExpression targetParam = Expression.Parameter(typeof(object), null);
ParameterExpression valueParam = Expression.Parameter(typeof(object), null);
Expression castTarget = ReflectionUtility.Convert(targetParam, typeInfo);
Expression castValue = Expression.Convert(valueParam, info.PropertyType);
Expression propertySet = Expression.Call(castTarget, setMethod, castValue);
return(ReflectionUtility.CompileLambda <Action <object, object> >(propertySet, targetParam, valueParam));
});
}
public object CreateInstance(TypeInfo typeInfo, int initialCapacity, out TypeInfo resultTypeInfo)
{
resultTypeInfo = this.typeToConstruct.GetOrAdd(typeInfo, this.ComputeTypeToConstruct);
if (resultTypeInfo != null)
{
if (resultTypeInfo.CapacityConstructor is Func <int, object> capacityConstructor)
{
if (typeInfo.IsArray)
{
initialCapacity = (initialCapacity > 0) ? initialCapacity : Constants.BufferSize;
}
return(capacityConstructor(initialCapacity));
}
else if (resultTypeInfo.DefaultConstructor is Func <object> defaultConstructor)
{
return(defaultConstructor());
}
else
{
return(Activator.CreateInstance(resultTypeInfo.Type));
}
}
throw JsonException.New(Resources.Convert_CreateFailed, typeInfo.Type.FullName);
}
protected override void SetMemberObject(object target, object key, object value)
{
if (this.callSet.Value is Action <object, object, object> setValue)
{
setValue(target, key ?? this.GenerateKey(target), value);
}
else
{
throw JsonException.New(Resources.Convert_NoSetter, this.info.Name, this.info.DeclaringType.FullName);
}
}
public static void EncodeTokenAsString(FullToken token, TextWriter writer)
{
if (!token.HasType(TokenType.AnyValue))
{
throw JsonException.New(Resources.Convert_KeyStringFailed, token.Type);
}
if (!token.HasType(TokenType.AnyString))
{
writer.Write('\"');
}
EncodingUtility.EncodeToken(token.FullText, token.Token, writer);
if (!token.HasType(TokenType.AnyString))
{
writer.Write('\"');
}
}
public static Key DecodeToken(string text, Token token)
{
if (token.Type != TokenType.EncodedString)
{
return(new Key(text.Substring(token.Start, token.Length), token.Hash));
}
int cur = token.Start;
StringBuilder value = new StringBuilder(token.Length);
StringHasher hasher = StringHasher.Create();
for (int end = cur + token.Length; cur != -1 && cur < end;)
{
char ch = text[cur];
if (ch == '\\')
{
ch = (cur + 1 < end) ? text[cur + 1] : '\0';
switch (ch)
{
case '\"':
case '\\':
case '/':
hasher.AddChar(ch);
value.Append(ch);
cur += 2;
break;
case 'b':
hasher.AddChar('\b');
value.Append('\b');
cur += 2;
break;
case 'f':
hasher.AddChar('\f');
value.Append('\f');
cur += 2;
break;
case 'n':
hasher.AddChar('\n');
value.Append('\n');
cur += 2;
break;
case 'r':
hasher.AddChar('\r');
value.Append('\r');
cur += 2;
break;
case 't':
hasher.AddChar('\t');
value.Append('\t');
cur += 2;
break;
case 'u':
if (cur + 5 < end)
{
string buffer = text.Substring(cur + 2, 4);
if (uint.TryParse(buffer, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out uint decoded))
{
ch = (char)decoded;
hasher.AddChar(ch);
value.Append(ch);
cur += 6;
}
else
{
cur = -1;
}
}
else
{
cur = -1;
}
break;
default:
cur = -1;
break;
}
}
else
{
hasher.AddChar(ch);
value.Append(ch);
cur++;
}
}
if (cur == -1)
{
throw JsonException.New(Resources.Parser_InvalidStringToken);
}
return(new Key(value.ToString(), hasher.HashValue));
}
