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)); }