/// <summary>
/// Reads the JSON representation of the object.
/// </summary>
public override object ReadJson( Newtonsoft.Json.JsonReader reader, Type objectType, object existingValue, Newtonsoft.Json.JsonSerializer serializer )
{
var configuration = new Configuration();
while( reader.Read() && reader.TokenType == Newtonsoft.Json.JsonToken.PropertyName )
{
switch( reader.Value.ToString() )
{
case "partAttributes":
reader.Read();
configuration.PartAttributes = serializer.Deserialize<AbstractAttributeDefinition[]>( reader );
break;
case "characteristicAttributes":
reader.Read();
configuration.CharacteristicAttributes = serializer.Deserialize<AbstractAttributeDefinition[]>( reader );
break;
case "measurementAttributes":
reader.Read();
configuration.MeasurementAttributes = serializer.Deserialize<AbstractAttributeDefinition[]>( reader );
break;
case "valueAttributes":
reader.Read();
configuration.ValueAttributes = serializer.Deserialize<AbstractAttributeDefinition[]>( reader );
break;
case "catalogAttributes":
reader.Read();
configuration.CatalogAttributes = serializer.Deserialize<AttributeDefinition[]>( reader );
break;
}
}
return configuration;
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, Newtonsoft.Json.JsonSerializer serializer)
{
EthSolidityContract contract = new EthSolidityContract();
int startingDepth = reader.Depth;
while (!(reader.TokenType == JsonToken.EndObject && reader.Depth == startingDepth))
{
reader.Read();
if (reader.TokenType == JsonToken.PropertyName)
{
string propertyName = reader.Value.ToString();
if (String.Equals(propertyName, "code"))
{
reader.Read();
contract.Code = serializer.Deserialize<byte[]>(reader);
}
else if (String.Equals(propertyName, "info"))
{
reader.Read();
contract.Info = serializer.Deserialize<ContractInfo>(reader);
}
else
{
contract.ContractName = reader.Value.ToString();
reader.Read();
}
}
}
return contract;
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, Newtonsoft.Json.JsonSerializer serializer)
{
if (reader.TokenType == JsonToken.StartArray)
{
return serializer.Deserialize<IList<WeiboAnnotation>>(reader);
}
else
{
var media = serializer.Deserialize<WeiboAnnotation>(reader);
return new List<WeiboAnnotation>();
}
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, Newtonsoft.Json.JsonSerializer serializer)
{
EthWork work = new EthWork();
reader.Read();
work.BlockHash = serializer.Deserialize<byte[]>(reader);
reader.Read();
work.SeedHash = serializer.Deserialize<byte[]>(reader);
reader.Read();
work.BoundaryCondition = serializer.Deserialize<byte[]>(reader);
reader.Read();
return work;
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, Newtonsoft.Json.JsonSerializer serializer)
{
switch (reader.TokenType)
{
case JsonToken.StartArray:
IEnumerable<EthTopic> topics = serializer.Deserialize<IEnumerable<EthTopic>>(reader);
return new EthTopic(topics.ToArray());
case JsonToken.String:
byte[] value = serializer.Deserialize<byte[]>(reader);
return new EthTopic(value);
case JsonToken.Null:
return new EthTopic();
default:
throw new NotImplementedException();
}
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue,
Newtonsoft.Json.JsonSerializer serializer)
{
var result = new StationRank();
serializer.Converters.Add(new RowCollectionJsonConverter<StationRank.StationRankEntry>());
result.Stations = serializer.Deserialize<RowCollection<StationRank.StationRankEntry>>(reader);
return result;
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue,
Newtonsoft.Json.JsonSerializer serializer)
{
var result = new ItemHistory();
serializer.Converters.Add(new RowCollectionJsonConverter<ItemHistory.ItemHistoryEntry>());
result.History = serializer.Deserialize<RowCollection<ItemHistory.ItemHistoryEntry>>(reader);
return result;
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, Newtonsoft.Json.JsonSerializer serializer)
{
MerkleNode merkleNode = new MerkleNode();
int startingDepth = reader.Depth;
while (!(reader.TokenType == JsonToken.EndObject && startingDepth == reader.Depth))
{
reader.Read();
if (reader.TokenType == JsonToken.PropertyName)
{
string propertyName = reader.Value.ToString();
if (String.Equals(propertyName, "Data"))
{
reader.Read();
merkleNode.Data = serializer.Deserialize<byte[]>(reader);
}
else if (String.Equals(propertyName, "Hash"))
{
reader.Read();
merkleNode.Hash = serializer.Deserialize<MultiHash>(reader);
}
else if (String.Equals(propertyName, "Links"))
{
reader.Read();
merkleNode.Links = serializer.Deserialize<IEnumerable<MerkleNode>>(reader);
}
else if (String.Equals(propertyName, "Name"))
{
reader.Read();
merkleNode.Name = serializer.Deserialize<string>(reader);
}
else if (String.Equals(propertyName, "Size"))
{
reader.Read();
merkleNode.Size = serializer.Deserialize<long?>(reader);
}
}
}
return merkleNode;
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, Newtonsoft.Json.JsonSerializer serializer)
{
if(reader.TokenType == JsonToken.Boolean)
{
return new EthSyncing(false);
}
else
{
int depth = reader.Depth;
BigInteger startingBlock;
BigInteger currentBlock;
BigInteger highestBlock;
while (!(reader.TokenType == JsonToken.EndObject && reader.Depth == depth))
{
reader.Read();
if(reader.TokenType == JsonToken.PropertyName)
{
string propertyName = reader.Value.ToString();
if(String.Equals(propertyName, StartingBlockKey))
{
reader.Read();
startingBlock = serializer.Deserialize<BigInteger>(reader);
}
else if (String.Equals(propertyName, CurrentBlockKey))
{
reader.Read();
currentBlock = serializer.Deserialize<BigInteger>(reader);
}
else if (String.Equals(propertyName, HighestBlockKey))
{
reader.Read();
highestBlock = serializer.Deserialize<BigInteger>(reader);
}
}
}
return new EthSyncing(startingBlock, currentBlock, highestBlock);
}
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, Newtonsoft.Json.JsonSerializer serializer)
{
AbiDefinition abiDefinition = new AbiDefinition();
int startingDepth = reader.Depth;
while (!(reader.TokenType == JsonToken.EndObject && reader.Depth == startingDepth))
{
reader.Read();
if (reader.TokenType == JsonToken.PropertyName)
{
string propertyName = reader.Value.ToString();
if (String.Equals(propertyName, "contant"))
{
reader.Read();
abiDefinition.Constant = serializer.Deserialize<bool>(reader);
}
else if (String.Equals(propertyName, "name"))
{
reader.Read();
abiDefinition.Name = reader.Value.ToString();
}
else if (String.Equals(propertyName, "type"))
{
reader.Read();
abiDefinition.Type = reader.Value.ToString();
}
else if (String.Equals(propertyName, "inputs"))
{
reader.Read();
abiDefinition.Inputs = serializer.Deserialize<List<FunctionInputOutput>>(reader);
}
else if (String.Equals(propertyName, "outputs"))
{
reader.Read();
abiDefinition.Outputs = serializer.Deserialize<List<FunctionInputOutput>>(reader);
}
}
}
return abiDefinition;
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, Newtonsoft.Json.JsonSerializer serializer)
{
switch (reader.TokenType)
{
case JsonToken.String:
BigInteger bi = serializer.Deserialize<BigInteger>(reader);
return UnixEpoch.AddSeconds((int)bi);
default:
throw new NotImplementedException();
}
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue,
Newtonsoft.Json.JsonSerializer serializer)
{
var result = new RecentUploads();
JObject json = JObject.Load(reader);
serializer.Converters.Add(new RowSetCollectionJsonConverter<RecentUploads.RecentUploadsEntry>());
result.Uploads =
serializer.Deserialize<RowCollection<RecentUploads.RecentUploadsEntry>>(json["rowset"].CreateReader());
return result;
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue,
Newtonsoft.Json.JsonSerializer serializer) {
var serializedId = serializer.Deserialize<string>(reader);
if (serializedId == null)
return null;
var values = serializedId.Split(',');
return new CommitId(Guid.Parse(values[1]), new DateTime(long.Parse(values[0])));
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, Newtonsoft.Json.JsonSerializer serializer)
{
ContractInfo contractInfo = new ContractInfo();
int startingDepth = reader.Depth;
while (!(reader.TokenType == JsonToken.EndObject && reader.Depth == startingDepth))
{
reader.Read();
if (reader.TokenType == JsonToken.PropertyName)
{
string propertyName = reader.Value.ToString();
if (String.Equals(propertyName, "source"))
{
reader.Read();
contractInfo.Source = reader.Value.ToString();
}
else if (String.Equals(propertyName, "language"))
{
reader.Read();
contractInfo.Language = reader.Value.ToString();
}
else if (String.Equals(propertyName, "languageVersion"))
{
reader.Read();
contractInfo.LanguageVersion = reader.Value.ToString();
}
else if (String.Equals(propertyName, "compilerVersion"))
{
reader.Read();
contractInfo.CompilerVersion = reader.Value.ToString();
}
else if (String.Equals(propertyName, "compilerOptions"))
{
reader.Read();
contractInfo.CompilerOptions = reader.Value.ToString();
}
else if (String.Equals(propertyName, "abiDefinition"))
{
reader.Read();
contractInfo.AbiDefinition = serializer.Deserialize<List<AbiDefinition>>(reader);
}
}
}
return contractInfo;
}
/// <summary>
/// Reads the JSON representation of the object.
/// </summary>
public override object ReadJson( Newtonsoft.Json.JsonReader reader, Type objectType, object existingValue, Newtonsoft.Json.JsonSerializer serializer )
{
var catalog = new Catalog();
if( reader.TokenType == Newtonsoft.Json.JsonToken.StartObject )
{
while( reader.Read() && reader.TokenType != Newtonsoft.Json.JsonToken.EndObject )
{
switch( reader.Value.ToString() )
{
case "name": catalog.Name = reader.ReadAsString(); break;
case "uuid": catalog.Uuid = new Guid( reader.ReadAsString() ); break;
case "validAttributes":
if( reader.Read() && reader.TokenType == Newtonsoft.Json.JsonToken.StartArray )
{
var atts = new List<ushort>();
while( reader.Read() && reader.TokenType != Newtonsoft.Json.JsonToken.EndArray )
{
atts.Add( Convert.ToUInt16( reader.Value ) );
}
catalog.ValidAttributes = atts.ToArray();
}
break;
case "catalogEntries":
if( reader.Read() && reader.TokenType == Newtonsoft.Json.JsonToken.StartArray )
{
if( reader.Read() && reader.TokenType == Newtonsoft.Json.JsonToken.StartObject )
{
var entries = new List< CatalogEntry >();
while( reader.TokenType != Newtonsoft.Json.JsonToken.EndArray )
{
entries.Add(serializer.Deserialize<CatalogEntry>( reader ));
reader.Read();
}
catalog.CatalogEntries = entries.ToArray();
}
}
break;
}
}
}
return catalog;
}
/// <summary>
/// Reads the JSON representation of the object.
/// </summary>
public override object ReadJson( Newtonsoft.Json.JsonReader reader, Type objectType, object existingValue, Newtonsoft.Json.JsonSerializer serializer )
{
var catalogueEntry = new CatalogEntry();
while( reader.Read() && reader.TokenType == Newtonsoft.Json.JsonToken.PropertyName )
{
switch( reader.Value.ToString() )
{
case "key":
catalogueEntry.Key = short.Parse( reader.ReadAsString(), CultureInfo.InvariantCulture );
break;
case "attributes":
reader.Read();
catalogueEntry.Attributes = serializer.Deserialize<DataService.Attribute[]>( reader );
break;
}
}
return catalogueEntry;
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, Newtonsoft.Json.JsonSerializer serializer)
{
EthLog ethLog = new EthLog();
switch (reader.TokenType)
{
case JsonToken.StartObject:
int startingDepth = reader.Depth;
while (!(reader.TokenType == JsonToken.EndObject && startingDepth == reader.Depth))
{
reader.Read();
if (reader.TokenType == JsonToken.PropertyName)
{
string propertyName = reader.Value.ToString();
if (String.Equals(propertyName, "type"))
{
reader.Read();
ethLog.Type = serializer.Deserialize<EthLogType?>(reader);
}
else if (String.Equals(propertyName, "logIndex"))
{
reader.Read();
ethLog.LogIndex = serializer.Deserialize<BigInteger>(reader);
}
else if (String.Equals(propertyName, "blockNumber"))
{
reader.Read();
ethLog.BlockNumber = serializer.Deserialize<BigInteger>(reader);
}
else if (String.Equals(propertyName, "blockHash"))
{
reader.Read();
ethLog.BlockHash = serializer.Deserialize<byte[]>(reader);
}
else if (String.Equals(propertyName, "transactionHash"))
{
reader.Read();
ethLog.TransactionHash = serializer.Deserialize<byte[]>(reader);
}
else if (String.Equals(propertyName, "transactionIndex"))
{
reader.Read();
ethLog.TransactionIndex = serializer.Deserialize<BigInteger>(reader);
}
else if (String.Equals(propertyName, "address"))
{
reader.Read();
ethLog.Address = serializer.Deserialize<byte[]>(reader);
}
else if (String.Equals(propertyName, "data"))
{
reader.Read();
ethLog.Data = serializer.Deserialize<byte[]>(reader);
}
else if (String.Equals(propertyName, "topics"))
{
reader.Read();
ethLog.Topics = serializer.Deserialize<IEnumerable<byte[]>>(reader);
}
}
}
break;
case JsonToken.StartArray:
ethLog.Hashes = serializer.Deserialize<IEnumerable<byte[]>>(reader);
break;
default:
throw new NotImplementedException();
}
return ethLog;
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, Newtonsoft.Json.JsonSerializer serializer)
{
BigInteger value = serializer.Deserialize<BigInteger>(reader);
return TimeSpan.FromSeconds((double)value);
}
private static dynamic NewtonsoftJsonDeserializeDynamic(Newtonsoft.Json.JsonSerializer jsonSerializer, string json)
{
using (var reader = new StringReader(json))
{
using (var jsonReader = new JsonTextReader(reader))
{
return jsonSerializer.Deserialize(jsonReader);
}
}
}
private static Foo2 NewtonsoftJsonDeserializeFoo2(Newtonsoft.Json.JsonSerializer jsonSerializer, string json)
{
using (var reader = new StringReader(json))
{
return (Foo2)jsonSerializer.Deserialize(reader, typeof(Foo2));
}
}
public override object ReadJson(Newtonsoft.Json.JsonReader reader, System.Type objectType, object existingValue, Newtonsoft.Json.JsonSerializer serializer)
{
var jObject = serializer.Deserialize<Newtonsoft.Json.Linq.JObject>(reader);
if (jObject == null)
return null;
var newSerializer = new Newtonsoft.Json.JsonSerializer();
newSerializer.ContractResolver = (Newtonsoft.Json.Serialization.IContractResolver)System.Activator.CreateInstance(serializer.ContractResolver.GetType());
GetField(typeof(Newtonsoft.Json.Serialization.DefaultContractResolver), "_sharedCache").SetValue(newSerializer.ContractResolver, false);
dynamic resolver = newSerializer.ContractResolver;
if (System.Reflection.RuntimeReflectionExtensions.GetRuntimeProperty(newSerializer.ContractResolver.GetType(), "IgnoreSerializableAttribute") != null)
resolver.IgnoreSerializableAttribute = true;
if (System.Reflection.RuntimeReflectionExtensions.GetRuntimeProperty(newSerializer.ContractResolver.GetType(), "IgnoreSerializableInterface") != null)
resolver.IgnoreSerializableInterface = true;
Newtonsoft.Json.Linq.JToken token;
if (jObject.TryGetValue("discriminator", System.StringComparison.OrdinalIgnoreCase, out token))
{
var discriminator = Newtonsoft.Json.Linq.Extensions.Value<string>(token);
if (objectType.Name.Equals(discriminator) == false)
{
var exceptionType = System.Type.GetType("System." + discriminator, false);
if (exceptionType != null)
objectType = exceptionType;
else
{
foreach (var pair in _searchedNamespaces)
{
exceptionType = pair.Value.GetType(pair.Key + "." + discriminator);
if (exceptionType != null)
{
objectType = exceptionType;
break;
}
}
}
}
}
var value = jObject.ToObject(objectType, newSerializer);
foreach (var property in GetExceptionProperties(value.GetType()))
{
var jValue = jObject.GetValue(resolver.GetResolvedPropertyName(property.Value));
var propertyValue = (object)jValue?.ToObject(property.Key.PropertyType);
if (property.Key.SetMethod != null)
property.Key.SetValue(value, propertyValue);
else
{
var field = GetField(objectType, "m_" + property.Value.Substring(0, 1).ToLowerInvariant() + property.Value.Substring(1));
if (field != null)
field.SetValue(value, propertyValue);
}
}
SetExceptionFieldValue(jObject, "Message", value, "_message", resolver, newSerializer);
SetExceptionFieldValue(jObject, "StackTrace", value, "_stackTraceString", resolver, newSerializer);
SetExceptionFieldValue(jObject, "Source", value, "_source", resolver, newSerializer);
SetExceptionFieldValue(jObject, "InnerException", value, "_innerException", resolver, serializer);
return value;
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, Newtonsoft.Json.JsonSerializer serializer)
{
EthBlock ethBlock = new EthBlock();
int startingDepth = reader.Depth;
while (!(reader.TokenType == JsonToken.EndObject && reader.Depth == startingDepth))
{
reader.Read();
if(reader.TokenType == JsonToken.PropertyName)
{
string propertyName = reader.Value.ToString();
if(String.Equals(propertyName, "number"))
{
reader.Read();
ethBlock.Number = serializer.Deserialize<BigInteger>(reader);
}
else if(String.Equals(propertyName, "hash"))
{
reader.Read();
ethBlock.Hash = serializer.Deserialize<byte[]>(reader);
}
else if (String.Equals(propertyName, "parentHash"))
{
reader.Read();
ethBlock.ParentHash = serializer.Deserialize<byte[]>(reader);
}
else if (String.Equals(propertyName, "nonce"))
{
reader.Read();
ethBlock.Nonce = serializer.Deserialize<byte[]>(reader);
}
else if (String.Equals(propertyName, "sha3Uncles"))
{
reader.Read();
ethBlock.Sha3Uncles = serializer.Deserialize<byte[]>(reader);
}
else if (String.Equals(propertyName, "logsBloom"))
{
reader.Read();
ethBlock.LogsBloom = serializer.Deserialize<byte[]>(reader);
}
else if (String.Equals(propertyName, "transactionsRoot"))
{
reader.Read();
ethBlock.TransactionRoot = serializer.Deserialize<byte[]>(reader);
}
else if (String.Equals(propertyName, "stateRoot"))
{
reader.Read();
ethBlock.StateRoot = serializer.Deserialize<byte[]>(reader);
}
else if (String.Equals(propertyName, "receiptRoot"))
{
reader.Read();
ethBlock.ReceiptRoot = serializer.Deserialize<byte[]>(reader);
}
else if (String.Equals(propertyName, "miner"))
{
reader.Read();
ethBlock.Miner = serializer.Deserialize<byte[]>(reader);
}
else if (String.Equals(propertyName, "difficulty"))
{
reader.Read();
ethBlock.Difficulty = serializer.Deserialize<BigInteger>(reader);
}
else if (String.Equals(propertyName, "totalDifficulty"))
{
reader.Read();
ethBlock.TotalDifficulty = serializer.Deserialize<BigInteger>(reader);
}
else if (String.Equals(propertyName, "extraData"))
{
reader.Read();
ethBlock.ExtraData = serializer.Deserialize<byte[]>(reader);
}
else if (String.Equals(propertyName, "size"))
{
reader.Read();
ethBlock.Size = serializer.Deserialize<BigInteger>(reader);
}
else if (String.Equals(propertyName, "gasLimit"))
{
reader.Read();
ethBlock.GasLimit = serializer.Deserialize<BigInteger>(reader);
}
else if (String.Equals(propertyName, "gasUsed"))
{
reader.Read();
ethBlock.GasUsed = serializer.Deserialize<BigInteger>(reader);
}
else if (String.Equals(propertyName, "timestamp"))
{
reader.Read();
ethBlock.TimeStamp = serializer.Deserialize<DateTimeOffset>(reader);
}
else if (String.Equals(propertyName, "transactions"))
{
reader.Read();
ethBlock.Transactions = serializer.Deserialize<IEnumerable<byte[]>>(reader);
}
else if (String.Equals(propertyName, "uncles"))
{
reader.Read();
ethBlock.Uncles = serializer.Deserialize<IEnumerable<byte[]>>(reader);
}
}
}
return ethBlock;
}
// caching ctor and Add method should help a ton -> delegates
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, Newtonsoft.Json.JsonSerializer serializer)
{
Type valueType = objectType.GetGenericArguments()[1];
object dict = objectType.GetConstructor(Type.EmptyTypes).Invoke(null);
MethodInfo addMethod = objectType.GetMethod("Add");
// Console.WriteLine("{0} {1} {2} {3}", valueType, reader.Value, reader.ValueType, reader.TokenType);
if (reader.TokenType != JsonToken.StartObject)
{
throw new JsonReaderException("Expected Newtonsoft.Json.JsonToken.StartObject");
}
reader.Read();
while (reader.TokenType != JsonToken.EndObject)
{
if (reader.TokenType != JsonToken.PropertyName)
{
throw new JsonReaderException("Expected Newtonsoft.Json.JsonToken.PropertyName");
}
IPAddress key = IPAddress.Parse((string)reader.Value);
reader.Read();
// Console.WriteLine("before value {0} {1} {2}", reader.Value, reader.ValueType, reader.TokenType);
object value = serializer.Deserialize(reader, valueType);
addMethod.Invoke(dict, new object[] { key, value });
reader.Read();
// Console.WriteLine("after add {0} {1} {2}", reader.Value, reader.ValueType, reader.TokenType);
}
//reader.Value
return dict;
}
public override object ReadJson(Newtonsoft.Json.JsonReader reader, System.Type objectType, object existingValue, Newtonsoft.Json.JsonSerializer serializer)
{
var jObject = serializer.Deserialize<Newtonsoft.Json.Linq.JObject>(reader);
var discriminator = Newtonsoft.Json.Linq.Extensions.Value<string>(jObject.GetValue(_discriminator));
var subtype = GetObjectSubtype(objectType, discriminator);
try
{
_isReading = true;
return serializer.Deserialize(jObject.CreateReader(), subtype);
}
finally
{
_isReading = false;
}
}
public IElasticItem ReadElasticJson(JsonReader reader, Type objectType, object existingValue, Newtonsoft.Json.JsonSerializer serializer)
{
return new GenericJsonItem(serializer.Deserialize<Dictionary<string, object>>(reader));
}
