public static DubProjectConfiguration DeserializeFromPackageJson(JsonReader j) { var c = new DubProjectConfiguration { Name = "<Undefined>" }; var srz = new JsonSerializer(); while (j.Read() && j.TokenType != JsonToken.EndObject) { if (j.TokenType == JsonToken.PropertyName) { switch (j.Value as string) { case "name": c.Name = c.Id = j.ReadAsString(); break; case "platforms": j.Read(); c.Platform = string.Join("|",srz.Deserialize<string[]>(j)); break; default: if (!c.BuildSettings.TryDeserializeBuildSetting(j)) j.Skip(); break; } } } return c; }
protected virtual object ReadJsonAsStringArray(JsonReader reader) { if (reader.TokenType != JsonToken.StartArray) { reader.Skip(); return null; } var rowValues = new List<string>(); var valueStartDepth = reader.Depth; var sb = new StringBuilder(); using (var sw = new StringWriter(sb)) { using (var jw = new JsonTextWriter(sw)) { while (reader.Read() && !(reader.TokenType == JsonToken.EndArray && reader.Depth == valueStartDepth)) { jw.WriteToken(reader, true); rowValues.Add(sb.ToString()); sb.Clear(); } } } return rowValues.ToArray(); }
/// <summary> /// Reads the JSON representation of the object. /// </summary> public sealed override object ReadJson( JsonReader reader, Type objectType, [AllowNull] object existingValue, JsonSerializer serializer) { if (reader.TokenType != JsonToken.StartObject) { return DeserializeLiteral(reader, objectType, serializer); } object value = null; while (reader.TokenType != JsonToken.EndObject) { reader.Read(); if (reader.TokenType == JsonToken.PropertyName && Equals(reader.Value, "@value")) { reader.Read(); value = DeserializeLiteral(reader, objectType, serializer); } else { reader.Skip(); } } return value; }
protected virtual object[] ReadAsObjectArray(JsonReader reader) { if (reader.TokenType != JsonToken.StartArray) { reader.Skip(); return null; } var rowValues = new List<object>(); var valueStartDepth = reader.Depth; while (reader.Read() && !(reader.TokenType == JsonToken.EndArray && reader.Depth == valueStartDepth)) { rowValues.Add(reader.Value); } return rowValues.ToArray(); }
private void SetObjectMember(JsonReader reader, object target, Type targetType, string memberName) { JsonMemberMappingCollection memberMappings = GetMemberMappings(targetType); JsonMemberMapping memberMapping; // attempt exact case match first // then try match ignoring case if (memberMappings.TryGetClosestMatchMapping(memberName, out memberMapping)) { SetMappingValue(memberMapping, reader, target); } else { if (_missingMemberHandling == MissingMemberHandling.Error) { throw new JsonSerializationException("Could not find member '{0}' on object of type '{1}'".FormatWith(CultureInfo.InvariantCulture, memberName, targetType.Name)); } reader.Skip(); } }
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) { bool flag = ReflectionUtils.IsNullableType(objectType); if (reader.TokenType == JsonToken.Null) { if (!flag) throw JsonSerializationException.Create(reader, "Cannot convert null value to KeyValuePair."); else return (object) null; } else { Type type = flag ? Nullable.GetUnderlyingType(objectType) : objectType; IList<Type> list = (IList<Type>) type.GetGenericArguments(); Type objectType1 = list[0]; Type objectType2 = list[1]; object obj1 = (object) null; object obj2 = (object) null; reader.Read(); while (reader.TokenType == JsonToken.PropertyName) { string a = reader.Value.ToString(); if (string.Equals(a, "Key", StringComparison.OrdinalIgnoreCase)) { reader.Read(); obj1 = serializer.Deserialize(reader, objectType1); } else if (string.Equals(a, "Value", StringComparison.OrdinalIgnoreCase)) { reader.Read(); obj2 = serializer.Deserialize(reader, objectType2); } else reader.Skip(); reader.Read(); } return ReflectionUtils.CreateInstance(type, obj1, obj2); } }
public static void ReadObject <TItem, TRoot>(this JsonReader reader, TRoot root, TItem item, Dictionary <string, Action <JsonReader, TRoot, TItem> > setters, bool throwOnUnknown = true) { if (reader.TokenType == JsonToken.Null) { return; } reader.Expect(JsonToken.StartObject); reader.Read(); while (reader.TokenType == JsonToken.PropertyName) { string propertyName = (string)reader.Value; reader.Read(); if (setters.TryGetValue(propertyName, out var setter)) { setter(reader, root, item); reader.Read(); } else { if (throwOnUnknown) { throw new JsonReaderException($"Unknown property {typeof(TItem).Name}.{propertyName} at {Position(reader)}."); } else { reader.Skip(); reader.Read(); } } } reader.Expect(JsonToken.EndObject); }
public async Task<ISingleResourceDocument> Deserialize(JsonReader reader, string currentPath) { if (reader.TokenType != JsonToken.StartObject) throw new DeserializationException("Invalid document root", "Document root is not an object!", currentPath); IResourceObject primaryData = null; IMetadata metadata = null; while (reader.Read()) { if (reader.TokenType != JsonToken.PropertyName) break; // Has to be a property name var propertyName = (string)reader.Value; reader.Read(); switch (propertyName) { case RelatedDataKeyName: // TODO: If we want to capture related resources, this would be the place to do it reader.Skip(); break; case PrimaryDataKeyName: primaryData = await DeserializePrimaryData(reader, currentPath + "/" + PrimaryDataKeyName); break; case MetaKeyName: metadata = await _metadataFormatter.Deserialize(reader, currentPath + "/" + MetaKeyName); break; default: reader.Skip(); break; } } return new SingleResourceDocument(primaryData, new IResourceObject[] { }, metadata); }
private IDictionary<JsonProperty, object> ResolvePropertyAndConstructorValues(JsonObjectContract contract, JsonProperty containerProperty, JsonReader reader, Type objectType) { IDictionary<JsonProperty, object> dictionary = (IDictionary<JsonProperty, object>) new Dictionary<JsonProperty, object>(); bool flag = false; do { switch (reader.TokenType) { case JsonToken.PropertyName: string propertyName = reader.Value.ToString(); JsonProperty member = contract.ConstructorParameters.GetClosestMatchProperty(propertyName) ?? contract.Properties.GetClosestMatchProperty(propertyName); if (member != null) { if (member.PropertyContract == null) member.PropertyContract = this.GetContractSafe(member.PropertyType); JsonConverter converter = this.GetConverter(member.PropertyContract, member.MemberConverter, (JsonContainerContract) contract, containerProperty); if (!this.ReadForType(reader, member.PropertyContract, converter != null)) throw JsonSerializationException.Create(reader, StringUtils.FormatWith("Unexpected end when setting {0}'s value.", (IFormatProvider) CultureInfo.InvariantCulture, (object) propertyName)); if (!member.Ignored) { if (member.PropertyContract == null) member.PropertyContract = this.GetContractSafe(member.PropertyType); object obj = converter == null || !converter.CanRead ? this.CreateValueInternal(reader, member.PropertyType, member.PropertyContract, member, (JsonContainerContract) contract, containerProperty, (object) null) : converter.ReadJson(reader, member.PropertyType, (object) null, (JsonSerializer) this.GetInternalSerializer()); dictionary[member] = obj; goto case JsonToken.Comment; } else { reader.Skip(); goto case JsonToken.Comment; } } else { if (!reader.Read()) throw JsonSerializationException.Create(reader, StringUtils.FormatWith("Unexpected end when setting {0}'s value.", (IFormatProvider) CultureInfo.InvariantCulture, (object) propertyName)); if (this.Serializer.MissingMemberHandling == MissingMemberHandling.Error) throw JsonSerializationException.Create(reader, StringUtils.FormatWith("Could not find member '{0}' on object of type '{1}'", (IFormatProvider) CultureInfo.InvariantCulture, (object) propertyName, (object) objectType.Name)); reader.Skip(); goto case JsonToken.Comment; } case JsonToken.Comment: continue; case JsonToken.EndObject: flag = true; goto case JsonToken.Comment; default: throw JsonSerializationException.Create(reader, "Unexpected token when deserializing object: " + (object) reader.TokenType); } } while (!flag && reader.Read()); return dictionary; }
private void SetObjectMember(JsonReader reader, object target, Type targetType, string memberName) { JsonMemberMappingCollection memberMappings = GetMemberMappings(targetType); JsonMemberMapping memberMapping; // attempt exact case match first // then try match ignoring case if (memberMappings.TryGetClosestMatchMapping(memberName, out memberMapping)) { SetMappingValue(memberMapping, reader, target); } else { if (_missingMemberHandling == MissingMemberHandling.Error) throw new JsonSerializationException("Could not find member '{0}' on object of type '{1}'".FormatWith(CultureInfo.InvariantCulture, memberName, targetType.Name)); reader.Skip(); } }
private bool CalculatePropertyDetails(JsonProperty property, ref JsonConverter propertyConverter, JsonContainerContract containerContract, JsonProperty containerProperty, JsonReader reader, object target, out bool useExistingValue, out object currentValue, out JsonContract propertyContract, out bool gottenCurrentValue) { currentValue = (object) null; useExistingValue = false; propertyContract = (JsonContract) null; gottenCurrentValue = false; if (property.Ignored) { reader.Skip(); return true; } else { switch (property.ObjectCreationHandling.GetValueOrDefault(this.Serializer.ObjectCreationHandling)) { case ObjectCreationHandling.Auto: case ObjectCreationHandling.Reuse: if ((reader.TokenType == JsonToken.StartArray || reader.TokenType == JsonToken.StartObject) && property.Readable) { currentValue = property.ValueProvider.GetValue(target); gottenCurrentValue = true; useExistingValue = currentValue != null && !property.PropertyType.IsArray && !ReflectionUtils.InheritsGenericDefinition(property.PropertyType, typeof (ReadOnlyCollection<>)) && !TypeExtensions.IsValueType(property.PropertyType); break; } else break; } if (!property.Writable && !useExistingValue) { reader.Skip(); return true; } else if (property.NullValueHandling.GetValueOrDefault(this.Serializer.NullValueHandling) == NullValueHandling.Ignore && reader.TokenType == JsonToken.Null) { reader.Skip(); return true; } else if (this.HasFlag(property.DefaultValueHandling.GetValueOrDefault(this.Serializer.DefaultValueHandling), DefaultValueHandling.Ignore) && JsonReader.IsPrimitiveToken(reader.TokenType) && MiscellaneousUtils.ValueEquals(reader.Value, property.GetResolvedDefaultValue())) { reader.Skip(); return true; } else { if (property.PropertyContract == null) property.PropertyContract = this.GetContractSafe(property.PropertyType); if (currentValue == null) { propertyContract = property.PropertyContract; } else { propertyContract = this.GetContractSafe(currentValue.GetType()); if (propertyContract != property.PropertyContract) propertyConverter = this.GetConverter(propertyContract, property.MemberConverter, containerContract, containerProperty); } return false; } } }
private object PopulateList(IWrappedCollection wrappedList, JsonReader reader, JsonArrayContract contract, JsonProperty containerProperty, string id) { object underlyingCollection = wrappedList.UnderlyingCollection; if (id != null) this.AddReference(reader, id, underlyingCollection); if (wrappedList.IsFixedSize) { reader.Skip(); return underlyingCollection; } else { contract.InvokeOnDeserializing(underlyingCollection, this.Serializer.Context); int depth = reader.Depth; JsonContract contractSafe = this.GetContractSafe(contract.CollectionItemType); JsonConverter converter = this.GetConverter(contractSafe, (JsonConverter) null, (JsonContainerContract) contract, containerProperty); int? nullable1 = new int?(); bool flag = false; do { try { if (this.ReadForType(reader, contractSafe, converter != null)) { switch (reader.TokenType) { case JsonToken.Comment: break; case JsonToken.EndArray: flag = true; break; default: object obj = converter == null || !converter.CanRead ? this.CreateValueInternal(reader, contract.CollectionItemType, contractSafe, (JsonProperty) null, (JsonContainerContract) contract, containerProperty, (object) null) : converter.ReadJson(reader, contract.CollectionItemType, (object) null, (JsonSerializer) this.GetInternalSerializer()); wrappedList.Add(obj); break; } } else break; } catch (Exception ex) { JsonPosition position = reader.GetPosition(depth); if (this.IsErrorHandled(underlyingCollection, (JsonContract) contract, (object) position.Position, reader.Path, ex)) { this.HandleError(reader, true, depth); if (nullable1.HasValue) { int? nullable2 = nullable1; int? nullable3 = position.Position; if ((nullable2.GetValueOrDefault() != nullable3.GetValueOrDefault() ? 0 : (nullable2.HasValue == nullable3.HasValue ? 1 : 0)) != 0) throw JsonSerializationException.Create(reader, "Infinite loop detected from error handling.", ex); } nullable1 = position.Position; } else throw; } } while (!flag); if (!flag) this.ThrowUnexpectedEndException(reader, (JsonContract) contract, underlyingCollection, "Unexpected end when deserializing array."); contract.InvokeOnDeserialized(underlyingCollection, this.Serializer.Context); return underlyingCollection; } }
/// <summary> /// Parses the example. /// </summary> /// <param name="reader">The example to parse.</param> /// <param name="label"> /// Optional label, taking precedence over "_label" property found in <paramref name="reader"/>. /// If null, <paramref name="reader"/> will be inspected and the "_label" property used as label. /// </param> /// <returns>The VowpalWabbit native example.</returns> public VowpalWabbitExample Parse(JsonReader reader, ILabel label = null) { // avoid parameter passing for the sake of non-reentrantness this.reader = reader; using (VowpalWabbitMarshalContext context = new VowpalWabbitMarshalContext(this.vw)) using (VowpalWabbitMarshalContext defaultNamespaceContext = new VowpalWabbitMarshalContext(this.vw, context.ExampleBuilder)) { if (label != null) this.defaultMarshaller.MarshalLabel(context, label); if (!reader.Read() || reader.TokenType != JsonToken.StartObject) throw new VowpalWabbitJsonException(reader.Path, "Expected start object"); Namespace defaultNamespace = new Namespace(this.vw); using (defaultNamespaceContext.NamespaceBuilder = defaultNamespaceContext.ExampleBuilder.AddNamespace(VowpalWabbitConstants.DefaultNamespace)) { while (reader.Read()) { switch (reader.TokenType) { case JsonToken.PropertyName: var propertyName = (string)reader.Value; if (propertyName.StartsWith(FeatureIgnorePrefix)) { // special fields switch (propertyName) { case "_label": // passed in label has precedence if (label == null) this.ParseLabel(context); else reader.Skip(); break; //case "_shared": // break; //case "_multi": // break; default: reader.Skip(); break; } } else { if (!reader.Read()) throw new VowpalWabbitJsonException(reader.Path, "Unexpected end"); if (reader.TokenType == JsonToken.StartObject) this.ParseNamespaceAndFeatures(context, propertyName); else this.ParseFeature(defaultNamespaceContext, defaultNamespace, propertyName); } break; } } // append default namespaces features if we found some if (defaultNamespaceContext.StringExample != null && defaultNamespaceContext.StringExample.Length > 0) { context.StringExample.AppendFormat(CultureInfo.InvariantCulture, "| {0}", defaultNamespaceContext.StringExample); } } var vwExample = context.ExampleBuilder.CreateExample(); if (this.vw.Settings.EnableStringExampleGeneration) vwExample.VowpalWabbitString = context.StringExample.ToString(); return vwExample; } }
private void HandleError(JsonReader reader, bool readPastError, int initialDepth) { this.ClearErrorContext(); if (!readPastError) return; reader.Skip(); do ; while (reader.Depth > initialDepth + 1 && reader.Read()); }
/// <summary> /// Returns the number of action dependent examples found within <paramref name="reader"/>. /// </summary> /// <param name="reader">The JSON.</param> /// <param name="multiProperty">The optional multi property name.</param> /// <returns>Returns the number of action dependent examples.</returns> public static int GetNumberOfActionDependentExamples(JsonReader reader, string multiProperty = PropertyConfiguration.MultiPropertyDefault) { // handle the case when the reader is already positioned at JsonToken.StartObject if (reader.TokenType == JsonToken.None && !reader.Read()) throw new VowpalWabbitJsonException(reader, "Expected non-empty JSON"); if (reader.TokenType != JsonToken.StartObject) throw new VowpalWabbitJsonException(reader, "Expected start object"); while (reader.Read()) { if (!(reader.TokenType == JsonToken.PropertyName && (string)reader.Value == multiProperty)) { reader.Skip(); continue; } if (!reader.Read() || reader.TokenType != JsonToken.StartArray) throw new VowpalWabbitJsonException(reader, "Expected start arrray"); var exampleCount = 0; while(reader.Read() && reader.TokenType != JsonToken.EndArray) { exampleCount++; reader.Skip(); } return exampleCount; } return 0; }
private object CreateObjectFromNonDefaultConstructor(Type objectType, JsonReader reader) { // object should have a single constructor ConstructorInfo c = objectType.GetConstructors(BindingFlags.Public | BindingFlags.Instance).SingleOrDefault(); if (c == null) throw new JsonSerializationException("Could not find a public constructor for type {0}.".FormatWith(CultureInfo.InvariantCulture, objectType)); // create a dictionary to put retrieved values into JsonMemberMappingCollection memberMappings = GetMemberMappings(objectType); IDictionary<JsonMemberMapping, object> mappingValues = memberMappings.ToDictionary(kv => kv, kv => (object)null); bool exit = false; while (!exit && reader.Read()) { switch (reader.TokenType) { case JsonToken.PropertyName: string memberName = reader.Value.ToString(); if (!reader.Read()) throw new JsonSerializationException("Unexpected end when setting {0}'s value.".FormatWith(CultureInfo.InvariantCulture, memberName)); JsonMemberMapping memberMapping; // attempt exact case match first // then try match ignoring case if (memberMappings.TryGetClosestMatchMapping(memberName, out memberMapping)) { if (!memberMapping.Ignored) { Type memberType = ReflectionUtils.GetMemberUnderlyingType(memberMapping.Member); mappingValues[memberMapping] = CreateObject(reader, memberType, null, memberMapping.MemberConverter); } } else { if (_missingMemberHandling == MissingMemberHandling.Error) throw new JsonSerializationException("Could not find member '{0}' on object of type '{1}'".FormatWith(CultureInfo.InvariantCulture, memberName, objectType.Name)); reader.Skip(); } break; case JsonToken.EndObject: exit = true; break; default: throw new JsonSerializationException("Unexpected token when deserializing object: " + reader.TokenType); } } IDictionary<ParameterInfo, object> constructorParameters = c.GetParameters().ToDictionary(p => p, p => (object)null); IDictionary<JsonMemberMapping, object> remainingMappingValues = new Dictionary<JsonMemberMapping, object>(); foreach (KeyValuePair<JsonMemberMapping, object> mappingValue in mappingValues) { ParameterInfo matchingConstructorParameter = constructorParameters.ForgivingCaseSensitiveFind(kv => kv.Key.Name, mappingValue.Key.MappingName).Key; if (matchingConstructorParameter != null) constructorParameters[matchingConstructorParameter] = mappingValue.Value; else remainingMappingValues.Add(mappingValue); } object createdObject = ReflectionUtils.CreateInstance(objectType, constructorParameters.Values.ToArray()); // go through unused values and set the newly created object's properties foreach (KeyValuePair<JsonMemberMapping, object> remainingMappingValue in remainingMappingValues) { if (ShouldSetMappingValue(remainingMappingValue.Key, remainingMappingValue.Value)) ReflectionUtils.SetMemberValue(remainingMappingValue.Key.Member, createdObject, remainingMappingValue.Value); } return createdObject; }
public async Task<IResourceObject> Deserialize(JsonReader reader, string currentPath) { if (reader.TokenType != JsonToken.StartObject) throw new DeserializationException("Invalid resource object", "Expected an object.", currentPath); string type = null; string id = null; IMetadata metadata = null; IDictionary<string, JToken> attributes = null; IDictionary<string, IRelationshipObject> relationships = null; while (reader.Read()) { if (reader.TokenType == JsonToken.EndObject) break; var propertyName = (string)reader.Value; reader.Read(); switch (propertyName) { case TypeKeyName: type = (string) reader.Value; break; case IdKeyName: id = (string) reader.Value; break; case MetaKeyName: metadata = await _metadataFormatter.Deserialize(reader, currentPath + "/" + MetaKeyName); break; case AttributesKeyName: attributes = DeserializeAttributes(reader, currentPath + "/" + AttributesKeyName); break; case RelationshipsKeyName: relationships = await DeserializeRelationships(reader, currentPath + "/" + RelationshipsKeyName); break; default: reader.Skip(); break; } } if (string.IsNullOrEmpty(type)) throw new DeserializationException("Resource object missing type", "Expected a value for `type`", currentPath + "/type"); return new ResourceObject(type, id, attributes ?? new Dictionary<string, JToken>(), relationships ?? new Dictionary<string, IRelationshipObject>(), metadata: metadata); }
/// <summary> /// Reads the JSON representation of the object.</summary> /// <param name="reader">The <see cref="JsonReader"/> to read from.</param> /// <param name="objectType"> /// Type of the object.</param> /// <param name="existingValue"> /// The existing value of object being read.</param> /// <param name="serializer"> /// The calling serializer.</param> /// <returns> /// The object value.</returns> public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) { if (reader.TokenType == JsonToken.Null) return null; var row = (Row)(Activator.CreateInstance(objectType)); if (row == null) throw new JsonSerializationException(String.Format("No row of type {0} could be created.", objectType.Name)); row.TrackAssignments = true; if (!reader.Read()) throw new JsonSerializationException("Unexpected end when deserializing object."); int initialDepth = reader.Depth; do { switch (reader.TokenType) { case JsonToken.PropertyName: string fieldName = (string)reader.Value; if (!reader.Read()) throw new JsonSerializationException("Unexpected end when deserializing object."); var field = row.FindField(fieldName); if (ReferenceEquals(null, field)) field = row.FindFieldByPropertyName(fieldName); if (ReferenceEquals(null, field) && serializer.MissingMemberHandling == MissingMemberHandling.Error) throw new JsonSerializationException(String.Format("Could not find field '{0}' on row of type '{1}'", fieldName, objectType.Name)); while (reader.TokenType == JsonToken.Comment) reader.Read(); if (ReferenceEquals(null, field)) reader.Skip(); else field.ValueFromJson(reader, row, serializer); break; case JsonToken.EndObject: return row; default: throw new JsonSerializationException("Unexpected token when deserializing row: " + reader.TokenType); } } while (reader.Read()); throw new JsonSerializationException("Unexpected end when deserializing object."); }
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) { var depth = reader.Depth; string[] columns = null; var contract = (JsonArrayContract)serializer.ContractResolver.ResolveContract(objectType); object ret = existingValue; while (reader.Read() && reader.TokenType != JsonToken.EndObject && reader.Depth > depth) { while (reader.TokenType == JsonToken.PropertyName) { var prop = (string)reader.Value; if (prop == "columns") { reader.Read(); columns = serializer.Deserialize<string[]>(reader); } else if (prop == "data") { if (columns == null || columns.Length == 0) { reader.Skip(); } else { //Deserialize the data part if (existingValue == null) { if (contract.DefaultCreator != null) { ret = contract.DefaultCreator(); } else { ret = Activator.CreateInstance(objectType); } } var collectionItemType = contract.CollectionItemType; var lst = (IList) ret; if (!(reader.Read() && reader.TokenType == JsonToken.StartArray)) { throw new Exception("Expected to read an array"); } int arrayDepth = reader.Depth; while (reader.Read() && (reader.TokenType != JsonToken.EndArray && reader.Depth >= arrayDepth)) { //This is a row var item = new JObject(); if (reader.TokenType != JsonToken.StartArray) throw new Exception("Expected to read an array but found " + reader.TokenType.ToString()); int index = 0; int arrayDepth2 = reader.Depth; while (reader.Read() && (reader.TokenType != JsonToken.EndArray && reader.Depth >= arrayDepth2)) { item[columns[index]] = JToken.ReadFrom(reader); index++; } using (var subReader = item.CreateReader()) { lst.Add(serializer.Deserialize(subReader, collectionItemType)); } } if (reader.Depth > arrayDepth) throw new JsonReaderException("Unexpected end of content while reading array."); } } else { reader.Skip(); } } } return ret; }
private void SetObjectMember(JsonReader reader, object target, Type targetType, string memberName) { if (!reader.Read()) throw new JsonSerializationException("Unexpected end when setting {0}'s value.".FormatWith(CultureInfo.InvariantCulture, memberName)); MemberMappingCollection memberMappings = GetMemberMappings(targetType); Type memberType; object value; // test if a member with memberName exists on the type // otherwise test if target is a dictionary and assign value with the key if it is if (memberMappings.Contains(memberName)) { MemberMapping memberMapping = memberMappings[memberName]; if (memberMapping.Ignored) { reader.Skip(); return; } // get the member's underlying type memberType = ReflectionUtils.GetMemberUnderlyingType(memberMapping.Member); object currentValue = ReflectionUtils.GetMemberValue(memberMapping.Member, target); bool useExistingValue = (currentValue != null && (_objectCreationHandling == ObjectCreationHandling.Auto || _objectCreationHandling == ObjectCreationHandling.Reuse) && (reader.TokenType == JsonToken.StartArray || reader.TokenType == JsonToken.StartObject) && (!memberType.IsArray && !ReflectionUtils.IsSubClass(memberType, typeof(ReadOnlyCollection<>)))); if (!memberMapping.Writable && !useExistingValue) { reader.Skip(); return; } value = CreateObject(reader, memberType, (useExistingValue) ? currentValue : null); if (_nullValueHandling == NullValueHandling.Ignore && value == null) return; if (!useExistingValue) ReflectionUtils.SetMemberValue(memberMapping.Member, target, value); } else { if (_missingMemberHandling == MissingMemberHandling.Error) throw new JsonSerializationException("Could not find member '{0}' on object of type '{1}'".FormatWith(CultureInfo.InvariantCulture, memberName, targetType.GetType().Name)); } }
private static KeyValuePair<string, string> ReadItem(JsonReader reader, JsonSerializer serializer) { string key = null; string value = null; ReadAndAssert(reader); while (reader.TokenType == JsonToken.PropertyName) { string propertyName = reader.Value.ToString(); if (string.Equals(propertyName, "opt_name", StringComparison.OrdinalIgnoreCase)) { ReadAndAssert(reader); key = serializer.Deserialize<string>(reader); } else if (string.Equals(propertyName, "opt_value", StringComparison.OrdinalIgnoreCase)) { ReadAndAssert(reader); value = serializer.Deserialize<string>(reader); } else { reader.Skip(); } ReadAndAssert(reader); } return new KeyValuePair<string, string>(key, value); }
void TryPopulateProperty(DubProject prj, string propName, JsonReader j) { switch (propName.ToLowerInvariant()) { case "displayname": prj.Name = j.ReadAsString(); break; case "name": prj.packageName = j.ReadAsString(); break; case "description": prj.Description = j.ReadAsString(); break; case "copyright": prj.Copyright = j.ReadAsString(); break; case "homepage": prj.Homepage = j.ReadAsString(); break; case "authors": if (!j.Read() || j.TokenType != JsonToken.StartArray) throw new JsonReaderException("Expected [ when parsing Authors"); prj.Authors.Clear(); while (j.Read() && j.TokenType != JsonToken.EndArray) if (j.TokenType == JsonToken.String) prj.Authors.Add(j.Value as string); break; case "dependencies": if (!j.Read() || j.TokenType != JsonToken.StartObject) throw new JsonReaderException("Expected { when parsing Authors"); DeserializeDubPrjDependencies(j, prj.CommonBuildSettings); break; case "configurations": if (!j.Read() || j.TokenType != JsonToken.StartArray) throw new JsonReaderException("Expected [ when parsing Configurations"); var sln = prj.ParentSolution; if (sln != null && sln.Configurations.Count == 1 && sln.Configurations[0].Id == DubProjectConfiguration.DefaultConfigId) sln.Configurations.Clear(); if (prj.Configurations.Count == 1 && prj.Configurations[0].Id == DubProjectConfiguration.DefaultConfigId) prj.Configurations.Clear(); while (j.Read() && j.TokenType != JsonToken.EndArray) prj.AddProjectAndSolutionConfiguration(DeserializeFromPackageJson(j)); break; case "subpackages": if (!j.Read() || j.TokenType != JsonToken.StartArray) throw new JsonReaderException("Expected [ when parsing subpackages"); while (j.Read() && j.TokenType != JsonToken.EndArray) ReadSubPackage(prj, j); break; case "buildtypes": if (!j.Read() || j.TokenType != JsonToken.StartObject) throw new JsonReaderException("Expected [ when parsing build types"); while (j.Read() && j.TokenType != JsonToken.EndObject) { var n = j.Value as string; if (!prj.buildTypes.Contains(n)) prj.buildTypes.Add(n); j.Skip(); } prj.buildTypes.Sort(); break; default: TryDeserializeBuildSetting(prj.CommonBuildSettings, j); break; } }
bool TryDeserializeBuildSetting(DubBuildSettings cfg, JsonReader j) { if (!(j.Value is string)) return false; var settingIdentifier = (j.Value as string).Split(new[] { '-' }, StringSplitOptions.RemoveEmptyEntries); if (settingIdentifier.Length < 1) return false; var propName = settingIdentifier[0] = settingIdentifier[0].ToLowerInvariant(); DubBuildSetting sett = null; switch (propName) { case "dependencies": j.Read(); DeserializeDubPrjDependencies(j, cfg); break; case "targettype": case "targetname": case "targetpath": case "workingdirectory": case "mainsourcefile": j.Read(); if (j.TokenType == JsonToken.String) { sett = new DubBuildSetting { Name = propName, Values = new[] { j.Value as string } }; } break; case "subconfigurations": j.Read(); var configurations = (new JsonSerializer()).Deserialize<Dictionary<string, string>>(j); foreach (var kv in configurations) cfg.subConfigurations[kv.Key] = kv.Value; break; case "sourcefiles": case "sourcepaths": case "excludedsourcefiles": case "versions": case "debugversions": case "importpaths": case "stringimportpaths": j.Read(); if (j.TokenType == JsonToken.StartArray) { sett = new DubBuildSetting { Name = propName, Values = (new JsonSerializer()).Deserialize<string[]>(j) }; for (int i = 1; i < settingIdentifier.Length; i++) { var pn = settingIdentifier[i].ToLowerInvariant(); if (sett.OperatingSystem == null && DubBuildSettings.OsVersions.Contains(pn)) sett.OperatingSystem = pn; else if (sett.Architecture == null && DubBuildSettings.Architectures.Contains(pn)) sett.Architecture = pn; else sett.Compiler = pn; } } break; default: j.Skip(); return false; } if (sett != null) { List<DubBuildSetting> setts; if (!cfg.TryGetValue(settingIdentifier[0], out setts)) cfg.Add(settingIdentifier[0], setts = new List<DubBuildSetting>()); setts.Add(sett); } return true; }
private static ApiErrorException ParseError(JsonReader jsonReader) { var error = new ApiErrorException(); while (jsonReader.Read()) { if (jsonReader.TokenType == JsonToken.PropertyName) { switch ((string)jsonReader.Value) { case "message": error.ErrorMessage = jsonReader.ReadAsString(); break; case "stack": error.ErrorStackTrace = jsonReader.ReadAsString(); break; case "type": error.ErrorType = jsonReader.ReadAsString(); break; default: jsonReader.Skip(); break; } } } return error; }
private object Deserialize(Type objectType, JsonReader reader, object obj = null) { object retval = obj == null ? Activator.CreateInstance(objectType) : obj; if (reader.TokenType != JsonToken.StartObject) throw new JsonReaderException(String.Format("Expected JsonToken.StartObject, got {0}", reader.TokenType.ToString())); reader.Read(); // Burn the StartObject token do { if (reader.TokenType == JsonToken.PropertyName) { string value = (string)reader.Value; var modelProperty = _modelManager.GetPropertyForJsonKey(objectType, value); if (value == RelationshipsKeyName) { // This can only happen within a links object reader.Read(); // burn the PropertyName token //TODO: linked resources (Done??) DeserializeLinkedResources(retval, reader); } else if (value == AttributesKeyName) { reader.Read(); retval = Deserialize(objectType, reader, retval); } else if (modelProperty != null) { if (!(modelProperty is FieldModelProperty)) { reader.Read(); // burn the PropertyName token //TODO: Embedded would be dropped here! continue; // These aren't supposed to be here, they're supposed to be in "related"! } var prop = modelProperty.Property; object propVal; Type enumType; if (prop.PropertyType == typeof(string) && prop.GetCustomAttributes().Any(attr => attr is SerializeStringAsRawJsonAttribute)) { reader.Read(); if (reader.TokenType == JsonToken.Null) { propVal = null; } else { var token = JToken.Load(reader); var rawPropVal = token.ToString(); propVal = JsonHelpers.MinifyJson(rawPropVal); } } else if (prop.PropertyType.IsGenericType && prop.PropertyType.GetGenericTypeDefinition() == typeof(Nullable<>) && (enumType = prop.PropertyType.GetGenericArguments()[0]).IsEnum) { // Nullable enums need special handling reader.Read(); propVal = reader.TokenType == JsonToken.Null ? null : Enum.Parse(enumType, reader.Value.ToString()); } else if (prop.PropertyType == typeof(DateTimeOffset) || prop.PropertyType == typeof(DateTimeOffset?)) { // For some reason reader.ReadAsString(); propVal = reader.TokenType == JsonToken.Null ? (object) null : DateTimeOffset.Parse(reader.Value.ToString()); } else { reader.Read(); propVal = DeserializeAttribute(prop.PropertyType, reader); } prop.SetValue(retval, propVal, null); // Tell the MetadataManager that we deserialized this property MetadataManager.Instance.SetMetaForProperty(retval, prop, true); // pop the value off the reader, so we catch the EndObject token below!. reader.Read(); } else { // Unexpected/unknown property--Skip the propertyname and its value reader.Skip(); if (reader.TokenType == JsonToken.StartArray || reader.TokenType == JsonToken.StartObject) reader.Skip(); else reader.Read(); } } } while (reader.TokenType != JsonToken.EndObject); reader.Read(); // burn the EndObject token before returning back up the call stack return retval; }
private object CreateObjectFromNonDefaultConstructor(Type objectType, JsonReader reader) { // object should have a single constructor ConstructorInfo c = objectType.GetConstructors(BindingFlags.Public | BindingFlags.Instance).SingleOrDefault(); if (c == null) { throw new JsonSerializationException("Could not find a public constructor for type {0}.".FormatWith(CultureInfo.InvariantCulture, objectType)); } // create a dictionary to put retrieved values into JsonMemberMappingCollection memberMappings = GetMemberMappings(objectType); IDictionary <JsonMemberMapping, object> mappingValues = memberMappings.ToDictionary(kv => kv, kv => (object)null); bool exit = false; while (!exit && reader.Read()) { switch (reader.TokenType) { case JsonToken.PropertyName: string memberName = reader.Value.ToString(); if (!reader.Read()) { throw new JsonSerializationException("Unexpected end when setting {0}'s value.".FormatWith(CultureInfo.InvariantCulture, memberName)); } JsonMemberMapping memberMapping; // attempt exact case match first // then try match ignoring case if (memberMappings.TryGetClosestMatchMapping(memberName, out memberMapping)) { if (!memberMapping.Ignored) { Type memberType = ReflectionUtils.GetMemberUnderlyingType(memberMapping.Member); mappingValues[memberMapping] = CreateObject(reader, memberType, null, memberMapping.MemberConverter); } } else { if (_missingMemberHandling == MissingMemberHandling.Error) { throw new JsonSerializationException("Could not find member '{0}' on object of type '{1}'".FormatWith(CultureInfo.InvariantCulture, memberName, objectType.Name)); } reader.Skip(); } break; case JsonToken.EndObject: exit = true; break; default: throw new JsonSerializationException("Unexpected token when deserializing object: " + reader.TokenType); } } IDictionary <ParameterInfo, object> constructorParameters = c.GetParameters().ToDictionary(p => p, p => (object)null); IDictionary <JsonMemberMapping, object> remainingMappingValues = new Dictionary <JsonMemberMapping, object>(); foreach (KeyValuePair <JsonMemberMapping, object> mappingValue in mappingValues) { ParameterInfo matchingConstructorParameter = constructorParameters.ForgivingCaseSensitiveFind(kv => kv.Key.Name, mappingValue.Key.MappingName).Key; if (matchingConstructorParameter != null) { constructorParameters[matchingConstructorParameter] = mappingValue.Value; } else { remainingMappingValues.Add(mappingValue); } } object createdObject = ReflectionUtils.CreateInstance(objectType, constructorParameters.Values.ToArray()); // go through unused values and set the newly created object's properties foreach (KeyValuePair <JsonMemberMapping, object> remainingMappingValue in remainingMappingValues) { if (ShouldSetMappingValue(remainingMappingValue.Key, remainingMappingValue.Value)) { ReflectionUtils.SetMemberValue(remainingMappingValue.Key.Member, createdObject, remainingMappingValue.Value); } } return(createdObject); }
private object PopulateObject(object newObject, JsonReader reader, JsonObjectContract contract, JsonProperty member, string id) { contract.InvokeOnDeserializing(newObject, this.Serializer.Context); Dictionary<JsonProperty, JsonSerializerInternalReader.PropertyPresence> dictionary = contract.HasRequiredOrDefaultValueProperties || this.HasFlag(this.Serializer.DefaultValueHandling, DefaultValueHandling.Populate) ? Enumerable.ToDictionary<JsonProperty, JsonProperty, JsonSerializerInternalReader.PropertyPresence>((IEnumerable<JsonProperty>) contract.Properties, (Func<JsonProperty, JsonProperty>) (m => m), (Func<JsonProperty, JsonSerializerInternalReader.PropertyPresence>) (m => JsonSerializerInternalReader.PropertyPresence.None)) : (Dictionary<JsonProperty, JsonSerializerInternalReader.PropertyPresence>) null; if (id != null) this.AddReference(reader, id, newObject); int depth = reader.Depth; bool flag = false; do { switch (reader.TokenType) { case JsonToken.PropertyName: string propertyName = reader.Value.ToString(); try { JsonProperty closestMatchProperty = contract.Properties.GetClosestMatchProperty(propertyName); if (closestMatchProperty == null) { if (this.Serializer.MissingMemberHandling == MissingMemberHandling.Error) throw JsonSerializationException.Create(reader, StringUtils.FormatWith("Could not find member '{0}' on object of type '{1}'", (IFormatProvider) CultureInfo.InvariantCulture, (object) propertyName, (object) contract.UnderlyingType.Name)); reader.Skip(); goto case JsonToken.Comment; } else { if (closestMatchProperty.PropertyContract == null) closestMatchProperty.PropertyContract = this.GetContractSafe(closestMatchProperty.PropertyType); JsonConverter converter = this.GetConverter(closestMatchProperty.PropertyContract, closestMatchProperty.MemberConverter, (JsonContainerContract) contract, member); if (!this.ReadForType(reader, closestMatchProperty.PropertyContract, converter != null)) throw JsonSerializationException.Create(reader, StringUtils.FormatWith("Unexpected end when setting {0}'s value.", (IFormatProvider) CultureInfo.InvariantCulture, (object) propertyName)); this.SetPropertyPresence(reader, closestMatchProperty, dictionary); this.SetPropertyValue(closestMatchProperty, converter, (JsonContainerContract) contract, member, reader, newObject); goto case JsonToken.Comment; } } catch (Exception ex) { if (this.IsErrorHandled(newObject, (JsonContract) contract, (object) propertyName, reader.Path, ex)) { this.HandleError(reader, true, depth); goto case JsonToken.Comment; } else throw; } case JsonToken.Comment: continue; case JsonToken.EndObject: flag = true; goto case JsonToken.Comment; default: throw JsonSerializationException.Create(reader, "Unexpected token when deserializing object: " + (object) reader.TokenType); } } while (!flag && reader.Read()); if (!flag) this.ThrowUnexpectedEndException(reader, (JsonContract) contract, newObject, "Unexpected end when deserializing object."); this.EndObject(newObject, reader, contract, depth, dictionary); contract.InvokeOnDeserialized(newObject, this.Serializer.Context); return newObject; }
private void SetMappingValue(JsonMemberMapping memberMapping, JsonReader reader, object target) { if (memberMapping.Ignored) { reader.Skip(); return; } // get the member's underlying type Type memberType = ReflectionUtils.GetMemberUnderlyingType(memberMapping.Member); object currentValue = null; bool useExistingValue = false; if ((_objectCreationHandling == ObjectCreationHandling.Auto || _objectCreationHandling == ObjectCreationHandling.Reuse) && (reader.TokenType == JsonToken.StartArray || reader.TokenType == JsonToken.StartObject)) { currentValue = ReflectionUtils.GetMemberValue(memberMapping.Member, target); useExistingValue = (currentValue != null && !memberType.IsArray && !ReflectionUtils.InheritsGenericDefinition(memberType, typeof(ReadOnlyCollection<>))); } if (!memberMapping.Writable && !useExistingValue) { reader.Skip(); return; } object value = CreateObject(reader, memberType, (useExistingValue) ? currentValue : null, JsonTypeReflector.GetConverter(memberMapping.Member, memberType)); if (!useExistingValue && ShouldSetMappingValue(memberMapping, value)) ReflectionUtils.SetMemberValue(memberMapping.Member, target, value); }
public bool TryPopulateProperty(string propName, JsonReader j, IProgressMonitor monitor) { switch (propName.ToLowerInvariant()) { case "displayname": displayName = j.ReadAsString (); break; case "name": packageName = j.ReadAsString(); break; case "description": Description = j.ReadAsString(); break; case "copyright": Copyright = j.ReadAsString(); break; case "homepage": Homepage = j.ReadAsString(); break; case "authors": if (!j.Read() || j.TokenType != JsonToken.StartArray) throw new JsonReaderException("Expected [ when parsing Authors"); authors.Clear(); while (j.Read() && j.TokenType != JsonToken.EndArray) if (j.TokenType == JsonToken.String) authors.Add(j.Value as string); break; case "dependencies": if (!j.Read () || j.TokenType != JsonToken.StartObject) throw new JsonReaderException ("Expected { when parsing Authors"); DubReferences.DeserializeDubPrjDependencies(j, monitor); break; case "configurations": if (!j.Read() || j.TokenType != JsonToken.StartArray) throw new JsonReaderException("Expected [ when parsing Configurations"); if(ParentSolution != null && ParentSolution.Configurations.Count == 1 && ParentSolution.Configurations[0].Id == DubProjectConfiguration.DefaultConfigId) ParentSolution.Configurations.Clear(); if(Configurations.Count == 1 && Configurations[0].Id == DubProjectConfiguration.DefaultConfigId) Configurations.Clear(); while (j.Read() && j.TokenType != JsonToken.EndArray) AddProjectAndSolutionConfiguration(DubProjectConfiguration.DeserializeFromPackageJson(j)); break; case "subpackages": if (!j.Read () || j.TokenType != JsonToken.StartArray) throw new JsonReaderException ("Expected [ when parsing subpackages"); while (j.Read () && j.TokenType != JsonToken.EndArray) DubSubPackage.ReadAndAdd (this, j, monitor); break; case "buildtypes": if (!j.Read() || j.TokenType != JsonToken.StartObject) throw new JsonReaderException("Expected [ when parsing build types"); while (j.Read() && j.TokenType != JsonToken.EndObject) { var n = j.Value as string; if (!buildTypes.Contains(n)) buildTypes.Add(n); j.Skip(); } buildTypes.Sort(); break; default: return CommonBuildSettings.TryDeserializeBuildSetting(j); } return true; }
/// <summary> /// Parses the example. /// </summary> /// <param name="reader">The example to parse.</param> /// <param name="label"> /// Optional label, taking precedence over "_label" property found in <paramref name="reader"/>. /// If null, <paramref name="reader"/> will be inspected and the "_label" property used as label. /// </param> public void Parse(JsonReader reader, ILabel label = null) { // avoid parameter passing for the sake of non-reentrantness this.reader = reader; if (label != null) this.defaultMarshaller.MarshalLabel(this.Context, label); // handle the case when the reader is already positioned at JsonToken.StartObject if (reader.TokenType == JsonToken.None && !reader.Read()) return; if (reader.TokenType != JsonToken.StartObject) throw new VowpalWabbitJsonException(reader.Path, "Expected start object"); Namespace defaultNamespace = new Namespace(this.vw); using (this.DefaultNamespaceContext.NamespaceBuilder = this.DefaultNamespaceContext.ExampleBuilder.AddNamespace(VowpalWabbitConstants.DefaultNamespace)) { while (reader.Read()) { switch (reader.TokenType) { case JsonToken.PropertyName: var propertyName = (string)reader.Value; if (propertyName.StartsWith(FeatureIgnorePrefix)) { // special fields switch (propertyName) { case "_label": // passed in label has precedence if (label == null) this.ParseLabel(); else reader.Skip(); break; //case "_shared": // break; //case "_multi": // break; default: reader.Skip(); break; } } else { if (!reader.Read()) throw new VowpalWabbitJsonException(reader.Path, "Unexpected end"); if (reader.TokenType == JsonToken.StartObject) this.ParseNamespaceAndFeatures(this.Context, propertyName); else this.ParseFeature(this.DefaultNamespaceContext, defaultNamespace, propertyName); } break; case JsonToken.EndObject: goto done; } } done: // append default namespaces features if we found some if (this.DefaultNamespaceContext.StringExample != null && this.DefaultNamespaceContext.StringExample.Length > 0) { this.Context.StringExample.AppendFormat(CultureInfo.InvariantCulture, " | {0}", this.DefaultNamespaceContext.StringExample); } } }
/// <summary> /// Reads the JSON representation of the object. /// </summary> /// <param name="reader">The <see cref="JsonReader"/> to read from.</param> /// <param name="objectType">Type of the object.</param> /// <param name="existingValue">The existing value of object being read.</param> /// <param name="serializer">The calling serializer.</param> /// <returns>The object value.</returns> public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) { bool isNullable = ReflectionUtils.IsNullableType(objectType); Type t = (isNullable) ? Nullable.GetUnderlyingType(objectType) : objectType; ReflectionObject reflectionObject = ReflectionObjectPerType.Get(t); if (reader.TokenType == JsonToken.Null) { if (!isNullable) throw JsonSerializationException.Create(reader, "Cannot convert null value to KeyValuePair."); return null; } object key = null; object value = null; ReadAndAssert(reader); while (reader.TokenType == JsonToken.PropertyName) { string propertyName = reader.Value.ToString(); if (string.Equals(propertyName, KeyName, StringComparison.OrdinalIgnoreCase)) { ReadAndAssert(reader); key = serializer.Deserialize(reader, reflectionObject.GetType(KeyName)); } else if (string.Equals(propertyName, ValueName, StringComparison.OrdinalIgnoreCase)) { ReadAndAssert(reader); value = serializer.Deserialize(reader, reflectionObject.GetType(ValueName)); } else { reader.Skip(); } ReadAndAssert(reader); } return reflectionObject.Creator(key, value); }
private void DeserializeLinkedResources(object obj, JsonReader reader) { if (reader.TokenType != JsonToken.StartObject) throw new JsonSerializationException("'links' property is not an object!"); Type objectType = obj.GetType(); while (reader.Read()) { if (reader.TokenType == JsonToken.EndObject) { reader.Read(); // Burn the EndObject token break; } if (reader.TokenType != JsonToken.PropertyName) throw new BadRequestException(String.Format("Unexpected token: {0}", reader.TokenType)); var value = (string)reader.Value; reader.Read(); // burn the PropertyName token var modelProperty = _modelManager.GetPropertyForJsonKey(objectType, value) as RelationshipModelProperty; if (modelProperty == null) { reader.Skip(); continue; } var relationshipToken = JToken.ReadFrom(reader); if (!(relationshipToken is JObject)) throw new BadRequestException("Each relationship key on a links object must have an object value."); var relationshipObject = (JObject) relationshipToken; var linkageToken = relationshipObject[PrimaryDataKeyName]; var linkageObjects = new List<Tuple<string, string>>(); if (modelProperty.IsToMany) { if (linkageToken == null) throw new BadRequestException("Expected an array value for `linkage` but no `linkage` key was found."); if (linkageToken.Type != JTokenType.Array) throw new BadRequestException("Expected an array value for `linkage` but got " + linkageToken.Type + "."); foreach (var element in (JArray) linkageToken) { if (!(element is JObject)) throw new BadRequestException("Each element in the `linkage` array must be an object."); var linkageObject = DeserializeLinkageObject((JObject) element); linkageObjects.Add(linkageObject); } } else { if (linkageToken == null) throw new BadRequestException("Expected an object or null value for `linkage` but no `linkage` key was found."); switch (linkageToken.Type) { case JTokenType.Null: break; case JTokenType.Object: linkageObjects.Add(DeserializeLinkageObject((JObject)linkageToken)); break; default: throw new BadRequestException("Expected an object value for `linkage` but got " + linkageToken.Type + "."); } } var relatedStubs = linkageObjects.Select(lo => { var resourceType = _modelManager.GetTypeByResourceTypeName(lo.Item2); return GetById(resourceType, lo.Item1); }).ToArray(); var prop = modelProperty.Property; if (!modelProperty.IsToMany) { // To-one relationship var relatedStub = relatedStubs.FirstOrDefault(); prop.SetValue(obj, relatedStub); } else { // To-many relationship var hmrel = (IEnumerable<Object>) prop.GetValue(obj, null); if (hmrel == null) { hmrel = prop.PropertyType.CreateEnumerableInstance(); if (hmrel == null) // punt! throw new JsonReaderException( String.Format( "Could not create empty container for relationship property {0}!", prop)); } // We're having problems with how to generalize/cast/generic-ize this code, so for the time // being we'll brute-force it in super-dynamic language style... Type hmtype = hmrel.GetType(); MethodInfo add = hmtype.GetMethod("Add"); foreach (var stub in relatedStubs) { add.Invoke(hmrel, new[] {stub}); } prop.SetValue(obj, hmrel); } // Tell the MetadataManager that we deserialized this property MetadataManager.Instance.SetMetaForProperty(obj, prop, true); } }
private Regex ReadRegexObject(JsonReader reader, JsonSerializer serializer) { string pattern = null; RegexOptions? options = null; while (reader.Read()) { switch (reader.TokenType) { case JsonToken.PropertyName: string propertyName = reader.Value.ToString(); if (!reader.Read()) throw JsonSerializationException.Create(reader, "Unexpected end when reading Regex."); if (string.Equals(propertyName, PatternName, StringComparison.OrdinalIgnoreCase)) pattern = (string)reader.Value; else if (string.Equals(propertyName, OptionsName, StringComparison.OrdinalIgnoreCase)) options = serializer.Deserialize<RegexOptions>(reader); else reader.Skip(); break; case JsonToken.Comment: break; case JsonToken.EndObject: if (pattern == null) throw JsonSerializationException.Create(reader, "Error deserializing Regex. No pattern found."); return new Regex(pattern, options ?? RegexOptions.None); } } throw JsonSerializationException.Create(reader, "Unexpected end when reading Regex."); }