public override object ReadJson(JsonReader reader, Type objectType, object existingValue,
JsonSerializer serializer)
{
if (reader.TokenType == JsonToken.StartArray)
{
var list = new List<ShardsSegment>();
serializer.Populate(reader, list);
return list.First();
}
var o = new ShardsSegment();
serializer.Populate(reader, o);
return o;
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
if (reader.TokenType == JsonToken.Null)
return null;
var keyType = objectType.GetGenericArguments()[0];
var keyValueType = keyType.BaseType.GetGenericArguments()[0];
var valueType = objectType.GetGenericArguments()[1];
var intermediateDictionaryType = typeof(Dictionary<,>).MakeGenericType(typeof(string), valueType);
var intermediateDictionary = (IDictionary)Activator.CreateInstance(intermediateDictionaryType);
serializer.Populate(reader, intermediateDictionary);
var valueProperty = keyType.GetProperty("Value");
var finalDictionary = (IDictionary)Activator.CreateInstance(objectType);
foreach (DictionaryEntry pair in intermediateDictionary)
{
object value;
if (keyValueType == typeof(Guid))
value = Guid.Parse(pair.Key.ToString());
else
value = Convert.ChangeType(pair.Key, keyValueType, null);
var key = Activator.CreateInstance(keyType);
valueProperty.SetValue(key, value, null);
finalDictionary.Add(key, pair.Value);
}
return finalDictionary;
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
var dict = new Dictionary<string, Dictionary<string, Dictionary<string, IndexSettings>>>();
serializer.Populate(reader, dict);
var response = new IndexSettingsResponse();
if (!dict.HasAny() || !dict.First().Value.HasAny() || !dict.First().Value.First().Value.HasAny())
return response;
response.Nodes = dict.ToDictionary(k => k.Key, v => v.Value.First().Value.First().Value);
return response;
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue,
JsonSerializer serializer)
{
reader.Read();
if (reader.TokenType != JsonToken.PropertyName)
return null;
var key = reader.Value as string;
reader.Read();
switch (key)
{
case "delete":
var deleteItem = new BulkDeleteResponseItem();
serializer.Populate(reader, deleteItem);
if (deleteItem != null)
deleteItem.Operation = key;
reader.Read();
return deleteItem;
case "update":
var updateItem = new BulkUpdateResponseItem();
serializer.Populate(reader, updateItem);
if (updateItem != null)
updateItem.Operation = key;
reader.Read();
return updateItem;
case "index":
var indexItem = new BulkIndexResponseItem();
serializer.Populate(reader, indexItem);
if (indexItem != null)
indexItem.Operation = key;
reader.Read();
return indexItem;
case "create":
var createItem = new BulkCreateResponseItem();
serializer.Populate(reader, createItem);
if (createItem != null)
createItem.Operation = key;
reader.Read();
return createItem;
}
return null;
}
/// <summary>
/// Reads the JSON representation of the object.
/// </summary>
/// <param name="reader">
/// The <see cref="T:Newtonsoft.Json.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;
object obj = Container.Resolve(objectType);
if (obj == null)
throw new JsonSerializationException("No object created.");
serializer.Populate(reader, obj);
return obj;
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
if (reader.TokenType != JsonToken.StartObject) return null;
reader.Read();
if (reader.TokenType != JsonToken.PropertyName) return null;
var prop = reader.Value;
if ((string) reader.Value != "filter") return null;
reader.Read();
var agg = new FilterAggregator();
serializer.Populate(reader, agg);
return agg;
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
if (reader.TokenType == JsonToken.StartObject)
{
var denormalizedReference = new DenormalizedReference();
serializer.Populate(reader, denormalizedReference);
var referenceInstace = _generator.CreateClassProxyWithTarget(
denormalizedReference.ReferenceInstanceType,
new Type[] { typeof(IDynamicProxy) },
InstanceCreator.Create(denormalizedReference.ReferenceInstanceType),
new ReferenceInterceptor(denormalizedReference.Id, denormalizedReference.ReferenceInstanceType));
return referenceInstace;
}
return null;
}
/// <summary>
/// Reads the JSON representation of the object.
/// </summary>
/// <param name="reader">
/// The <see cref="T:Newtonsoft.Json.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;
using (var scope=Container.BeginScope())
{
object obj = scope.Resolve(objectType);
if (obj == null)
throw new JsonSerializationException("No object created.");
serializer.Populate(reader, obj);
/*RefrenceHacks.SkipRefrences = true;
scope.Scope.InjectUnsetProperties(obj);
RefrenceHacks.SkipRefrences = false;*/
return obj;
}
}
public static T ReadData <T>(Stream strm) where T : new()
{
var data = new T();
using (var rdr = new BsonDataReader(new BinaryReader(strm, DefaultEncoding, true)))
{
if (data is ISerializablePayloadData)
{
((ISerializablePayloadData)data).Deserialize(rdr);
}
else
{
Serializer.Populate(rdr, data);
}
return(data);
}
// var serializer = MessagePackSerializer.Get<T>();
// return serializer.Unpack(strm);
}
public static void FromJsonFile <T>(string fileName, T obj)
{
if (!File.Exists(fileName))
{
throw new FileNotFoundException(fileName);
}
var serializer = new JsonSerializer();
serializer.Converters.Add(new JavaScriptDateTimeConverter());
serializer.NullValueHandling = NullValueHandling.Ignore;
using (var fileStream = new FileStream(fileName, FileMode.Open)) {
using (var streamReader = new StreamReader(fileStream)) {
using (var reader = new JsonTextReader(streamReader)) {
serializer.Populate(reader, obj);
}
}
}
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
if (reader == null)
{
throw new ArgumentNullException("Reader");
}
if (serializer == null)
{
throw new ArgumentNullException("Serializer");
}
if (reader.TokenType == JsonToken.Null)
{
return(null);
}
JObject jObject = JObject.Load(reader);
T target = Create(objectType, jObject);
serializer.Populate(jObject.CreateReader(), target);
return(target);
}
/// <summary>
/// Reads Json in a Objekt und creates a Property
/// </summary>
/// <param name="reader"></param>
/// <param name="objectType"></param>
/// <param name="existingValue"></param>
/// <param name="serializer"></param>
/// <returns></returns>
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
var jObject = JObject.Load(reader);
string type = jObject["type"]?.Value <string>();
Grantee grantee = null;
if (!String.IsNullOrEmpty(type))
{
GranteeTypes granteeType = (GranteeTypes)Enum.Parse(typeof(GranteeTypes), type);
grantee = CreateGrantee(granteeType);
serializer.Populate(jObject.CreateReader(), grantee);
}
else
{
throw new InvalidOperationException("Empty grantee type.");
}
return(grantee);
}
public override IChart ReadJson(JsonReader reader, Type objectType,
IChart existingValue, bool hasExistingValue, JsonSerializer serializer)
{
var jsonObject = JObject.Load(reader);
var type = jsonObject["Type"] ?? jsonObject["type"];
var chartType = EnumUtil.GetFromString <ChartType>(type.Value <string>());
IChart contentBlock = chartType switch
{
ChartType.Line => new LineChart(),
ChartType.HorizontalBar => new HorizontalBarChart(),
ChartType.VerticalBar => new VerticalBarChart(),
ChartType.Map => new MapChart(),
ChartType.Infographic => new InfographicChart(),
_ => throw new ArgumentOutOfRangeException()
};
serializer.Populate(jsonObject.CreateReader(), contentBlock);
return(contentBlock);
}
public override object ReadJson(JsonReader reader,
Type objectType, object existingValue,
JsonSerializer serializer)
{
var jsonObject = JObject.Load(reader);
var plotConfig = default(IPlotConfig);
string objectTypeName = jsonObject["TypeName"].Value <string>();
if (objectTypeName == typeof(LinePlotConfig).Name)
{
plotConfig = new LinePlotConfig();
}
if (plotConfig != null)
{
serializer.Populate(jsonObject.CreateReader(), plotConfig);
}
return(plotConfig);
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
JObject jo = JObject.Load(reader);
object messageType;
if (Enum.TryParse(typeof(MessageType), jo["mt"].Value <string>(), true, out messageType))
{
MessageBase message = Create((MessageType)messageType);
if (message != null)
{
serializer.Populate(jo.CreateReader(), message);
}
return(message);
}
return(null);
}
private object CreateObject(Type objectType, JsonSerializer serializer, JObject jsonObject)
{
var createdObject = Activator.CreateInstance(objectType);
// We need to remember the currently populating object for the next properties on the same hierarchy.
// We could use a Stack<object> here, as well - ofc, parentPopulating lives on the "stack" too ;)
var parentPopulating = this.currentlyPopulating;
try
{
this.currentlyPopulating = createdObject;
serializer.Populate(jsonObject.CreateReader(), createdObject);
}
finally
{
this.currentlyPopulating = parentPopulating;
}
return(createdObject);
}
// Token: 0x0600094D RID: 2381 RVA: 0x0003D0B0 File Offset: 0x0003B2B0
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
if (reader.TokenType == JsonToken.Null)
{
return(null);
}
JToken jtoken = JObject.Load(reader);
GetNodesResponse getNodesResponse = new GetNodesResponse(this.masterKey);
JsonReader jsonReader = jtoken.CreateReader();
jsonReader.Culture = reader.Culture;
jsonReader.DateFormatString = reader.DateFormatString;
jsonReader.DateParseHandling = reader.DateParseHandling;
jsonReader.DateTimeZoneHandling = reader.DateTimeZoneHandling;
jsonReader.FloatParseHandling = reader.FloatParseHandling;
jsonReader.MaxDepth = reader.MaxDepth;
jsonReader.SupportMultipleContent = reader.SupportMultipleContent;
serializer.Populate(jsonReader, getNodesResponse);
return(getNodesResponse);
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
JObject jo = JObject.Load(reader);
var imagePaths = jo["ImagePaths"];
TrackerItem item;
if (imagePaths != null)
{
item = new UpgradableTrackerItem();
}
else
{
item = new TrackerItem();
}
serializer.Populate(jo.CreateReader(), item);
return(item);
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
var jObject = JObject.Load(reader);
var type = jObject["type"].Value <string>();
object target = null;
if (type == "Speech")
{
target = new SimulationSpeechResponse();
}
else
{
throw new InvalidOperationException("Unknown simulation response type: " + type);
}
serializer.Populate(jObject.CreateReader(), target);
return(target);
}
private static void CreateMultiHit <T>(MultiHitTuple tuple, JsonSerializer serializer, ICollection <IMultiGetHit <object> > collection) where T : class
{
var hit = new MultiGetHit <T>();
var reader = tuple.Hit.CreateReader();
serializer.Populate(reader, hit);
var contract = serializer.ContractResolver as SettingsContractResolver;
var settings = contract.ConnectionSettings;
var f = new FieldSelection <T>(settings);
var source = tuple.Hit["fields"];
if (source != null)
{
((IFieldSelection <T>)f).FieldValuesDictionary = serializer.Deserialize <Dictionary <string, object> >(source.CreateReader());
hit.FieldSelection = f;
}
collection.Add(hit);
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue,
JsonSerializer serializer)
{
if (reader.TokenType == JsonToken.Null)
{
return(null);
}
var jsonObject = JObject.Load(reader);
var target = Create(jsonObject);
if (target == null)
{
return(null);
}
serializer.Populate(jsonObject.CreateReader(), target);
return(target);
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
if (reader.TokenType == JsonToken.Null)
{
return(null);
}
var jObject = JObject.Load(reader);
var pair = ((string)jObject["pair"]).ToUpper();
var sep = pair.IndexOf("_", StringComparison.InvariantCulture);
var from = pair.Substring(0, sep);
var to = pair.Substring(sep + 1);
var instance = Activator.CreateInstance(objectType, from, to);
using (var jObjectReader = CopyReaderForObject(reader, jObject))
{
serializer.Populate(jObjectReader, instance);
}
return(instance);
}
public override object ReadJson(JsonReader reader,
Type objectType, object existingValue,
JsonSerializer serializer)
{
var jsonObject = JObject.Load(reader);
var profession = default(IProfession);
switch (jsonObject["JobTitle"].Value())
{
case "Software Developer":
profession = new Programming();
break;
case "Copywriter":
profession = new Writing();
break;
}
serializer.Populate(jsonObject.CreateReader(), profession);
return(profession);
}
public static void PopulateObject <T>(this JToken jToken, T obj)
{
if (jToken == null)
{
throw new System.ArgumentNullException(nameof(jToken), "Cannot Populate an object from a null JToken");
}
if (obj == null)
{
throw new System.ArgumentNullException(nameof(obj), "Cannot Populate a null object");
}
JsonSerializer serializer = new JsonSerializer();
serializer.Populate(jToken.CreateReader(), obj);
// Probably best to thrown an exception instead
// if (jToken != null) {
// JsonSerializer serializer = new JsonSerializer();
// serializer.Populate(jToken.CreateReader(), obj);
// }
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
// Load JObject from stream
JObject jObject = JObject.Load(reader);
var properties = jObject.Properties().ToList();
// deserialize automaticly
existingValue = existingValue ?? serializer.ContractResolver.ResolveContract(objectType).DefaultCreator();
// populate with reader created from current jObject, so we can re-use the reader. The original reader can't be reset, because it's forward-only
serializer.Populate(jObject.CreateReader(), existingValue);
// deserialize metadataproperties
var asset = (Asset)existingValue;
asset.MetaProperties = GetMetapropertyList(properties);
// Populate the object properties
return(asset);
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
var meta = _metaByType[objectType];
var item = JObject.Load(reader);
var discriminator = item[meta.DiscriminatorField].Value <string>();
var objectFactory = meta.GetObjectFactory(discriminator);
if (objectFactory == null)
{
throw new ArgumentException($"Unknown discriminator value '{discriminator}'.");
}
var target = objectFactory();
serializer.Populate(item.CreateReader(), target);
return(target);
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
IVirtualCompanionExecutionContextFeature feature = null;
if (reader.TokenType != JsonToken.Null)
{
var jObject = JObject.Load(reader);
var type = (VirtualCompanionExecutionContextFeatureType)jObject["Type"].Value <Int64>();
feature = CreateVirtualCompanionExecutionContextFeature(type);
if (feature != null)
{
using (JsonReader jObjectReader = jObject.CreateReader())
{
serializer.Populate(jObjectReader, feature);
}
}
}
return(feature);
}
public override IEnumerable <Source> ReadJson(JsonReader reader, Type objectType, IEnumerable <Source> existingValue, bool hasExistingValue,
JsonSerializer serializer)
{
var links = new Dictionary <string, string>();
serializer.Populate(reader, links);
return(links
.Select(l =>
{
var source = SourcesJson[l.Key];
var ret = new Source(
source.Type, source.Name,
source.BaseUrl, source.Emoji)
{
Link = l.Value
};
return ret;
}));
}
public override object ReadJson(
JsonReader reader,
Type objectType,
object existingValue,
JsonSerializer serializer)
{
//https://stackoverflow.com/questions/34185295/handling-null-objects-in-custom-jsonconverters-readjson-method
if (reader.TokenType == JsonToken.Null)
{
return(null);
}
var jObject = JArray.Load(reader);
T target = Create(objectType, jObject);
serializer.Populate(jObject.CreateReader(), target);
return(target);
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
var request = (OperationController.BaseOperationRequest)Activator.CreateInstance(objectType);
serializer.Populate(reader, request);
var operationSymbol = SymbolLogic <OperationSymbol> .ToSymbol(request.operationKey);
if (request.args != null)
{
for (int i = 0; i < request.args.Length; i++)
{
if (request.args[i] is JToken jtoken)
{
request.args[i] = ConvertObject(jtoken, serializer, operationSymbol);
}
}
}
return(request);
}
/// <summary>
/// Populates the object with values from the JSON string using <see cref="JsonSerializerSettings"/>.
/// </summary>
/// <param name="value">The JSON to populate values from.</param>
/// <param name="target">The target object to populate values onto.</param>
/// <param name="settings">
/// The <see cref="JsonSerializerSettings"/> used to deserialize the object.
/// If this is <c>null</c>, default serialization settings will be used.
/// </param>
public static void PopulateObject(string value, object target, JsonSerializerSettings settings)
{
JsonSerializer jsonSerializer = JsonSerializer.CreateDefault(settings);
using (JsonReader jsonReader = new JsonTextReader(new StringReader(value)))
{
jsonSerializer.Populate(jsonReader, target);
if (settings != null && settings.CheckAdditionalContent)
{
while (jsonReader.Read())
{
if (jsonReader.TokenType != JsonToken.Comment)
{
throw JsonSerializationException.Create(jsonReader, "Additional text found in JSON string after finishing deserializing object.");
}
}
}
}
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
JObject jObject = JObject.Load(reader);
TaskType taskType = (TaskType)jObject.GetValue("taskTypes").Value <Int64>();
Task task;
if (taskType.HasFlag(TaskType.Selection))
{
task = new SelectionTask();
}
else
{
task = new ManipulationTask();
}
serializer.Populate(jObject.CreateReader(), task);
return(task);
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
var elasticContractResolver = serializer.ContractResolver as ElasticContractResolver;
if (elasticContractResolver != null && elasticContractResolver.PiggyBackState != null &&
elasticContractResolver.PiggyBackState.ActualJsonConverter != null)
{
var realConcreteConverter = elasticContractResolver.PiggyBackState.ActualJsonConverter as ConcreteTypeConverter <T>;
if (realConcreteConverter != null)
{
return(GetUsingConcreteTypeConverter(reader, serializer, realConcreteConverter));
}
}
var instance = (Hit <T>)(typeof(Hit <T>).CreateInstance());
serializer.Populate(reader, instance);
instance.Fields = new FieldSelection <T>(elasticContractResolver.Infer, instance._fields);
return(instance);
}
public override IReadOnlyList <T> ReadJson(JsonReader reader, Type objectType, IReadOnlyList <T> existingValue, bool hasExistingValue, JsonSerializer serializer)
{
var list = new List <T>();
var obj = JObject.Load(reader);
var lookupTable = serializer.Deserialize <List <string> >(obj["$lookup_table"].CreateReader());
foreach (var tok in obj["$items"])
{
var itemReader = tok.CreateReader();
var typeName = lookupTable[(int)tok["$type"]];
var instance = (T)Activator.CreateInstance(Type.GetType(typeName));
serializer.Populate(itemReader, instance);
list.Add(instance);
}
return(list);
}
public override SettingEntry ReadJson(JsonReader reader, Type objectType, SettingEntry existingValue, bool hasExistingValue, JsonSerializer serializer)
{
var jObj = JObject.Load(reader);
string entryTypeString = jObj[SETTINGTYPE_KEY].Value <string>();
var entryType = Type.GetType(entryTypeString);
if (entryType == null)
{
Logger.Warn("Failed to load setting of missing type '{settingDefinedType}'.", entryTypeString);
return(null);
}
var entryGeneric = Activator.CreateInstance(typeof(SettingEntry <>).MakeGenericType(entryType));
serializer.Populate(jObj.CreateReader(), entryGeneric);
return(entryGeneric as SettingEntry);
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
if (objectType == typeof(TBase))
{
JObject jo = JObject.Load(reader);
string discriminator = jo[this.discriminatorField].ToString();
var subtype = this.subtypes.FirstOrDefault(s => s.Discriminator == discriminator);
if (subtype == null)
{
throw new InvalidCastException($"No subtypes defined for discriminator \"{this.discriminatorField}\" = \"{discriminator}\" for base type {typeof(TBase).Name}");
}
return(jo.ToObject(subtype.Subtype));
}
else
{
Object result = Activator.CreateInstance(objectType);
serializer.Populate(reader, result);
return(result);
}
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
if (reader.TokenType == JsonToken.Null)
{
return(null);
}
var jObject = JObject.Load(reader);
var target = Create(objectType);
if (target == null)
{
throw new JsonSerializationException("No object created.");
}
serializer.Populate(jObject.CreateReader(), target);
return(target);
}
// From http://stackoverflow.com/questions/17171737/how-to-deserialize-json-data-which-sometimes-is-an-empty-array-and-sometimes-a-s
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
if (reader.TokenType == JsonToken.StartArray)
{
reader.Read();
if (reader.TokenType != JsonToken.EndArray)
{
throw new JsonReaderException("Empty array expected.");
}
return(default(T));
}
var jObject = JObject.Load(reader);
// Create target object based on JObject
var target = new T();
// Populate the object properties
serializer.Populate(jObject.CreateReader(), target);
return(target);
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
JObject o = JObject.Load(reader);
var result = existingValue as Dictionary<string, AnalyzerBase> ?? new Dictionary<string, AnalyzerBase>();
foreach (var childProperty in o.Children<JProperty>())
{
var propertyName = childProperty.Name;
var typeProperty = ((JObject)childProperty.Value).Property("type");
typeProperty.Remove();
var typePropertyValue = typeProperty.Value.ToString();
Language language;
if (Enum.TryParse(typePropertyValue, true, out language))
{
typePropertyValue = "Language";
}
var itemType = Type.GetType("Nest." + typePropertyValue + "Analyzer", false, true);
AnalyzerBase item;
if (itemType == typeof(LanguageAnalyzer))
{
item = new LanguageAnalyzer(language);
serializer.Populate(childProperty.Value.CreateReader(), item);
}
else if (itemType != null)
{
item = serializer.Deserialize(childProperty.Value.CreateReader(), itemType) as AnalyzerBase;
}
else
{
continue;
}
result[propertyName] = item;
}
return result;
}
public void PopulateDictionary()
{
Dictionary<string, string> p = new Dictionary<string, string>();
JsonSerializer serializer = new JsonSerializer();
serializer.Populate(new StringReader(@"{""Name"":""James""}"), p);
Assert.AreEqual(1, p.Count);
Assert.AreEqual("James", p["Name"]);
}
public void PopulateListOfPeople()
{
List<Person> p = new List<Person>();
JsonSerializer serializer = new JsonSerializer();
serializer.Populate(new StringReader(@"[{""Name"":""James""},{""Name"":""Jim""}]"), p);
Assert.AreEqual(2, p.Count);
Assert.AreEqual("James", p[0].Name);
Assert.AreEqual("Jim", p[1].Name);
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue,
JsonSerializer serializer)
{
JObject o = JObject.Load(reader);
var result = new IndexSettings();
var dictionary = new Dictionary<string, object>();
serializer.Populate(o.CreateReader(), dictionary);
result.Settings = dictionary;
result.AsExpando = DynamicDictionary.Create(dictionary);
foreach (var rootProperty in o.Children<JProperty>())
{
if (rootProperty.Name.Equals("analysis", StringComparison.InvariantCultureIgnoreCase))
{
result.Analysis = serializer.Deserialize<AnalysisSettings>(rootProperty.Value.CreateReader());
result.Settings.Remove(rootProperty.Name);
}
else if (rootProperty.Name.Equals("warmers", StringComparison.InvariantCultureIgnoreCase))
{
foreach (var jWarmer in rootProperty.Value.Children<JProperty>())
{
result.Warmers[jWarmer.Name] = serializer.Deserialize<WarmerMapping>(jWarmer.Value.CreateReader());
}
result.Settings.Remove(rootProperty.Name);
}
else if (rootProperty.Name.Equals("similarity", StringComparison.InvariantCultureIgnoreCase))
{
result.Similarity = serializer.Deserialize<SimilaritySettings>(rootProperty.Value.CreateReader());
result.Settings.Remove(rootProperty.Name);
}
}
return result;
}
