public static object ObjectStringToType(StringSegment strType) { var type = ExtractType(strType); if (type != null) { var parseFn = Serializer.GetParseStringSegmentFn(type); var propertyValue = parseFn(strType); return(propertyValue); } if (JsConfig.ConvertObjectTypesIntoStringDictionary && !strType.IsNullOrEmpty()) { if (strType.GetChar(0) == JsWriter.MapStartChar) { var dynamicMatch = DeserializeDictionary <TSerializer> .ParseDictionary <string, object>(strType, null, v => Serializer.UnescapeString(v).Value, v => Serializer.UnescapeString(v).Value); if (dynamicMatch != null && dynamicMatch.Count > 0) { return(dynamicMatch); } } if (strType.GetChar(0) == JsWriter.ListStartChar) { return(DeserializeList <List <object>, TSerializer> .ParseStringSegment(strType)); } } return((JsConfig.TryToParsePrimitiveTypeValues ? ParsePrimitive(strType.Value) : null) ?? Serializer.UnescapeString(strType).Value); }
internal static ParseStringSegmentDelegate GetPropertyMethod(ITypeSerializer serializer, PropertyInfo propertyInfo) { var getPropertyFn = serializer.GetParseStringSegmentFn(propertyInfo.PropertyType); if (propertyInfo.PropertyType == typeof(object) || propertyInfo.PropertyType.HasInterface(typeof(IEnumerable <object>))) { var declaringTypeNamespace = propertyInfo.DeclaringType?.Namespace; if (declaringTypeNamespace == null || (!JsConfig.AllowRuntimeTypeInTypesWithNamespaces.Contains(declaringTypeNamespace) && !JsConfig.AllowRuntimeTypeInTypes.Contains(propertyInfo.DeclaringType.FullName))) { return(value => { var hold = JsState.IsRuntimeType; try { JsState.IsRuntimeType = true; return getPropertyFn(value); } finally { JsState.IsRuntimeType = hold; } }); } } return(getPropertyFn); }
public static ParseStringSegmentDelegate GetParseStringSegmentMethod(Type type) { var collectionInterface = type.GetTypeWithGenericInterfaceOf(typeof(ICollection <>)); if (collectionInterface == null) { throw new ArgumentException(string.Format("Type {0} is not of type ICollection<>", type.FullName)); } //optimized access for regularly used types if (type.HasInterface(typeof(ICollection <string>))) { return(value => ParseStringCollection(value, type)); } if (type.HasInterface(typeof(ICollection <int>))) { return(value => ParseIntCollection(value, type)); } var elementType = collectionInterface.GetGenericArguments()[0]; var supportedTypeParseMethod = Serializer.GetParseStringSegmentFn(elementType); if (supportedTypeParseMethod != null) { var createCollectionType = type.HasAnyTypeDefinitionsOf(typeof(ICollection <>)) ? null : type; return(value => ParseCollectionType(value, createCollectionType, elementType, supportedTypeParseMethod)); } return(null); }
public static TypeAccessor Create(ITypeSerializer serializer, TypeConfig typeConfig, FieldInfo fieldInfo) { return(new TypeAccessor { PropertyType = fieldInfo.FieldType, GetProperty = serializer.GetParseStringSegmentFn(fieldInfo.FieldType), SetProperty = GetSetFieldMethod(typeConfig, fieldInfo), }); }
public static ParseStringSpanDelegate GetParseStringSegmentMethod(Type type) { var mapInterface = type.GetTypeWithGenericInterfaceOf(typeof(KeyValuePair <,>)); var keyValuePairArgs = mapInterface.GetGenericArguments(); var keyTypeParseMethod = Serializer.GetParseStringSegmentFn(keyValuePairArgs[KeyIndex]); if (keyTypeParseMethod == null) { return(null); } var valueTypeParseMethod = Serializer.GetParseStringSegmentFn(keyValuePairArgs[ValueIndex]); if (valueTypeParseMethod == null) { return(null); } var createMapType = type.HasAnyTypeDefinitionsOf(typeof(KeyValuePair <,>)) ? null : type; return(value => ParseKeyValuePairType(value, createMapType, keyValuePairArgs, keyTypeParseMethod, valueTypeParseMethod)); }
public static object ParseTuple(Type tupleType, StringSegment value) { var index = 0; Serializer.EatMapStartChar(value, ref index); if (JsonTypeSerializer.IsEmptyMap(value, index)) { //return tupleType.CreateInstance(); return(ActivatorUtils.FastCreateInstance(tupleType)); } var genericArgs = tupleType.GetGenericArguments(); var argValues = new object[genericArgs.Length]; var valueLength = value.Length; while (index < valueLength) { var keyValue = Serializer.EatMapKey(value, ref index); Serializer.EatMapKeySeperator(value, ref index); var elementValue = Serializer.EatValue(value, ref index); if (!keyValue.HasValue) { continue; } var keyIndex = keyValue.Substring("Item".Length).ToInt() - 1; var parseFn = Serializer.GetParseStringSegmentFn(genericArgs[keyIndex]); argValues[keyIndex] = parseFn(elementValue); Serializer.EatItemSeperatorOrMapEndChar(value, ref index); } var ctor = tupleType.GetConstructors() .First(x => x.GetParameters().Length == genericArgs.Length); return(ctor.Invoke(argValues)); }