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