protected override void Parse(Newtonsoft.Json.Linq.JToken json)
{
base.Parse(json);
this.Id = JeanRichard.Xbmc.Lib.JsonHelpers.JObjectExtensions.ParseSimpleValue<int>(json, "id");
this.Label = JeanRichard.Xbmc.Lib.JsonHelpers.JObjectExtensions.ParseSimpleValue<string>(json, "label");
this.ParseExtension(json);
}
protected override IList<JsonProperty> CreateProperties(Type type, Newtonsoft.Json.MemberSerialization memberSerialization)
{
var properties = base.CreateProperties(type, memberSerialization);
if (properties.Count > 0)
{
foreach (var property in type.GetProperties())
{
var sensitiveDataAttributes = property.GetCustomAttributes(typeof(SensitiveDataAttribute), false);
if (!sensitiveDataAttributes.Any()) { continue; }
var mappedProperty = properties.FirstOrDefault(p => p.UnderlyingName == property.Name);
if (mappedProperty != null)
{
var attribute = (sensitiveDataAttributes[0] as SensitiveDataAttribute);
if (attribute.Direction == Direction.Output)
properties.Add(GetJsonProperty(type, mappedProperty, attribute));
else
{
mappedProperty.ValueProvider = new SensitiveDataValueProvider(property.Name, SaltGenerator);
}
}
}
}
return properties;
}
/// <summary>
/// Writes the JSON representation of the object.
/// </summary>
/// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
/// <param name="value">The value.</param>
/// <param name="serializer">Serializer</param>
public override void WriteJson(Newtonsoft.Json.JsonWriter writer, object value, JsonSerializer serializer)
{
if (value is DateTime || value is DateTime?)
{
DateTime date = value is DateTime ? (DateTime)value : (value as DateTime?).Value;
if (date != DateTime.MinValue)
{
writer.WriteValue(date.ToString(this.RenderMilliseconds ? DateTimeFormatMs : DateTimeFormat, CultureInfo.InvariantCulture));
}
else
{
writer.WriteRawValue("null");
}
return;
}
else
{
DateTimeOffset dateTimeOffset = (DateTimeOffset)value;
if (dateTimeOffset != DateTimeOffset.MinValue)
{
writer.WriteValue(dateTimeOffset.ToString(DateTimeFormat, CultureInfo.InvariantCulture));
}
else
{
writer.WriteRawValue("null");
}
}
writer.WriteRawValue("null");
}
public override object ReadJson(Newtonsoft.Json.JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
if (reader.ValueType == null)
{
var obj = JObject.Load(reader);
Type type = null;
var typeToken = obj["$type"];
if (typeToken != null)
{
string assemblyName = null;
var typeName = typeToken.Value<string>();
var assemblyIndex = typeName.IndexOf(',');
if (assemblyIndex > 0)
{
assemblyName = typeName.Substring(assemblyIndex + 1).Trim();
typeName = typeName.Substring(0, assemblyIndex);
}
type = serializer.Binder.BindToType(assemblyName, typeName);
}
else
type = objectType;
var target = Activator.CreateInstance(type);
serializer.Populate(obj.CreateReader(), target);
return target;
}
if (objectType == reader.ValueType)
return reader.Value;
var converter = GetConverter(objectType, reader.ValueType);
if (converter != null)
{
return converter.ConvertFrom(reader.Value);
}
return reader.Value;
}
protected override void Parse(Newtonsoft.Json.Linq.JToken json)
{
base.Parse(json);
this.Art = JeanRichard.Xbmc.Lib.JsonHelpers.JObjectExtensions.ParseJsonObject<Media.Artwork>(json, "art");
this.PlayCount = JeanRichard.Xbmc.Lib.JsonHelpers.JObjectExtensions.ParseSimpleValue<System.Nullable<int>>(json, "playcount", 0);
this.ParseExtension(json);
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, Newtonsoft.Json.JsonSerializer serializer)
{
bool isNullableType = (objectType.IsGenericType && objectType.GetGenericTypeDefinition() == typeof (Nullable<>));
object value = reader.Value;
DateTime result;
if (value is DateTime)
{
result = (DateTime) value;
}
else if (value is string)
{
// ISO 8601 String
result = DateTime.Parse((string) value, CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind);
}
else if (value is long)
{
// UNIX epoch timestamp (in seconds)
result = UnixEpochBase.AddSeconds((long) value);
}
else
{
throw new NotImplementedException(string.Format(CultureInfo.InvariantCulture, "Deserializing {0} back to {1} is not handled.", value.GetType().FullName, objectType.FullName));
}
if (isNullableType && result == default(DateTime))
{
return null; // do not set result on DateTime? field
}
return result;
}
public override void WriteJson(JsonWriter writer, object value, Newtonsoft.Json.JsonSerializer serializer)
{
if(value == null)
{
writer.WriteNull();
return;
}
var obj = value as EthSyncing;
if(obj.IsSynching)
{
writer.WriteStartObject();
writer.WritePropertyName(StartingBlockKey);
serializer.Serialize(writer, obj.StartingBlock.Value);
writer.WritePropertyName(CurrentBlockKey);
serializer.Serialize(writer, obj.CurrentBlock.Value);
writer.WritePropertyName(HighestBlockKey);
serializer.Serialize(writer, obj.HighestBlock.Value);
writer.WriteEndObject();
}
else
{
writer.WriteValue(false);
}
}
public override void WriteJson(Newtonsoft.Json.JsonWriter writer, object value, JsonSerializer serializer)
{
if (value is int[])
{
writer.WriteRawValue("[{0}]".FormatWith(((int[])value).Join(",", "{0}")));
}
}
public override void WriteJson(Newtonsoft.Json.JsonWriter writer, object value, JsonSerializer serializer)
{
if (value != null && value is ComponentListener)
{
ComponentListener componentListener = (ComponentListener)value;
if (!componentListener.IsDefault)
{
if (this.Owner is BaseItem)
{
componentListener.Owner = ((BaseItem)this.Owner).Owner;
}
else if (this.Owner is Control)
{
componentListener.Owner = (Control)this.Owner;
}
if (this.PropertyName.IsNotEmpty())
{
componentListener.SetArgumentList(this.Owner.GetType().GetProperty(this.PropertyName));
}
writer.WriteRawValue(new ClientConfig().Serialize(componentListener));
return;
}
}
writer.WriteRawValue("{}");
}
public override void WriteJson(Newtonsoft.Json.JsonWriter writer, object value, JsonSerializer serializer)
{
if (value is string)
{
writer.WriteRawValue(new JFunction((string)value).ToScript());
}
}
/// <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 )
{
if( typeof( DataService.Attribute ) == objectType )
{
var result = default( DataService.Attribute );
if( reader.Read() && reader.TokenType == Newtonsoft.Json.JsonToken.PropertyName )
{
var key = ushort.Parse( reader.Value.ToString(), System.Globalization.CultureInfo.InvariantCulture );
var value = reader.ReadAsString();
result = new DataService.Attribute( key, value );
}
return result;
}
else
{
var result = new List<DataService.Attribute>();
if( reader.TokenType == Newtonsoft.Json.JsonToken.StartObject )
{
while( reader.Read() && reader.TokenType == Newtonsoft.Json.JsonToken.PropertyName )
{
var key = ushort.Parse( reader.Value.ToString(), System.Globalization.CultureInfo.InvariantCulture );
var value = reader.ReadAsString();
result.Add( new DataService.Attribute( key, value ) );
}
}
return result.ToArray();
}
}
public override void WriteJson(JsonWriter writer, object value, Newtonsoft.Json.JsonSerializer serializer)
{
if(value == null)
{
writer.WriteNull();
return;
}
MerkleNode mn = value as MerkleNode;
writer.WriteStartObject();
writer.WritePropertyName("Data");
serializer.Serialize(writer, mn.Data);
writer.WritePropertyName("Hash");
serializer.Serialize(writer, mn.Hash);
writer.WritePropertyName("Links");
serializer.Serialize(writer, mn.Links);
writer.WritePropertyName("Name");
serializer.Serialize(writer, mn.Name);
writer.WritePropertyName("Size");
serializer.Serialize(writer, mn.Size);
writer.WriteEndObject();
}
//protected override JsonContract CreateContract(Type objectType)
//{
// JsonContract contract = base.CreateContract(objectType);
// // this will only be called once and then cached
// if (objectType.IsValueType || objectType.IsEnum || objectType == typeof(string))
// return contract;
// if (objectType.GetInterface("IEnumerable") != null)
// throw new ArgumentException("IEnumerable should not serialize!");
// contract.Converter = new EntityIdConverter();
// return contract;
//}
protected override JsonProperty CreateProperty(System.Reflection.MemberInfo member, Newtonsoft.Json.MemberSerialization memberSerialization)
{
JsonProperty property = base.CreateProperty(member, memberSerialization);
var propertyType = property.PropertyType;
if (propertyType.IsValueType || propertyType == typeof(string))
{
}
else if (propertyType.IsEnum)
{
//property.Converter = new Newtonsoft.Json.Converters.StringEnumConverter();
}
else if (propertyType.GetInterface("IEnumerable") != null)
{
property.ShouldSerialize =
instance =>
{
return false;
};
}
else
{
property.Converter = new EntityIdConverter();
}
return property;
}
public override void ParseJson(DbGeographyGeoJsonConverter converter, Newtonsoft.Json.Linq.JArray array)
{
var targetCoordinateSystem = (converter as EpsgDbGeometryConverter).CoordinateSystem;
//Cant convert if source dont have any coordinate system.
if (!CoordinateSystem.HasValue || CoordinateSystem == targetCoordinateSystem)
{
base.ParseJson(converter, array);
return;
}
Rings = new List<List<Position>>();
var rings = array.ToObject<double[][][]>();
var ringSizes = rings.Select(r => r.Length).ToArray();
var coordinateLength = rings.First().GroupBy(c => c.Length).Single().Key;
foreach (var ring in rings)
{
var flat = ring.SelectMany(s => s).ToArray();
Reproject.ReprojectPoints(flat, null,
ProjectionInfo.FromEpsgCode(CoordinateSystem.Value), ProjectionInfo.FromEpsgCode(targetCoordinateSystem.Value), 0, ringSizes[0]);
var ringList = new List<Position>();
for (int i = 0; i < flat.Length; i += coordinateLength)
ringList.Add(new Position(flat.Skip(i).Take(coordinateLength).ToArray()));
Rings.Add(ringList);
}
CoordinateSystem = targetCoordinateSystem;
}
protected override void Parse(Newtonsoft.Json.Linq.JToken json)
{
base.Parse(json);
this.Channelgroupid = JeanRichard.Xbmc.Lib.JsonHelpers.JObjectExtensions.ParseSimpleValue<System.Nullable<int>>(json, "channelgroupid", -1);
this.Channeltype = JeanRichard.Xbmc.Lib.JsonHelpers.JObjectExtensions.ParseEnum<PVR.Channel.Type>(json, "channeltype", PVR.Channel.Type.TV);
this.ParseExtension(json);
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, Newtonsoft.Json.JsonSerializer serializer)
{
if (reader.TokenType == JsonToken.Null)
{
return null;
}
if (reader.TokenType != JsonToken.StartArray)
{
return null;
}
reader.Read();
var coords = new double[2];
for (int i = 0; i < 2; ++i)
{
if (reader.TokenType == JsonToken.Float)
{
coords[i] = (double)reader.Value;
reader.Read();
}
else if (reader.TokenType == JsonToken.Integer)
{
coords[i] = (double)((long)reader.Value);
reader.Read();
}
}
var latitude = coords[0];
var longitude = coords[1];
return new TwitterGeoLocation.GeoCoordinates { Latitude = latitude, Longitude = longitude };
}
internal Position(Newtonsoft.Json.Linq.JToken json)
: this()
{
InstrumentUrl = new Url<Account>((string)json["instrument"]);
AverageBuyPrice = (decimal)json["average_buy_price"];
Quantity = (decimal)json["quantity"];
}
public override void WriteJson(JsonWriter writer, object value, Newtonsoft.Json.JsonSerializer serializer)
{
if (value != null)
{
writer.WriteValue((((bool) value) ? 1 : 0).ToString(CultureInfo.InvariantCulture));
}
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, Newtonsoft.Json.JsonSerializer serializer)
{
FunctionInputOutput functionInputOutput = new FunctionInputOutput();
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, "name"))
{
reader.Read();
functionInputOutput.Name = reader.Value.ToString();
}
else if (String.Equals(propertyName, "type"))
{
reader.Read();
functionInputOutput.Type = reader.Value.ToString();
}
}
}
return functionInputOutput;
}
public object Read(Newtonsoft.Json.JsonReader reader)
{
if (reader.TokenType != Newtonsoft.Json.JsonToken.StartObject)
throw new Exception();
int w = ReadIntProperty(reader, "Width");
int h = ReadIntProperty(reader, "Height");
int d = ReadIntProperty(reader, "Depth");
var grid = new TileData[d, h, w];
reader.Read();
if (reader.TokenType != Newtonsoft.Json.JsonToken.PropertyName || (string)reader.Value != "TileData")
throw new Exception();
ReadAndValidate(reader, Newtonsoft.Json.JsonToken.StartArray);
var queue = new BlockingCollection<Tuple<int, byte[]>>();
var readerTask = Task.Factory.StartNew(() =>
{
for (int i = 0; i < d; ++i)
{
reader.Read();
int z = (int)(long)reader.Value;
byte[] buf = reader.ReadAsBytes();
queue.Add(new Tuple<int, byte[]>(z, buf));
}
queue.CompleteAdding();
});
Parallel.For(0, d, i =>
{
var tuple = queue.Take();
int z = tuple.Item1;
byte[] arr = tuple.Item2;
using (var memStream = new MemoryStream(arr))
{
using (var decompressStream = new DeflateStream(memStream, CompressionMode.Decompress))
using (var streamReader = new BinaryReader(decompressStream))
{
for (int y = 0; y < h; ++y)
for (int x = 0; x < w; ++x)
grid[z, y, x].Raw = streamReader.ReadUInt64();
}
}
});
readerTask.Wait();
ReadAndValidate(reader, Newtonsoft.Json.JsonToken.EndArray);
ReadAndValidate(reader, Newtonsoft.Json.JsonToken.EndObject);
return grid;
}
public override object ReadJson (Newtonsoft.Json.JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
var store = existingValue as PropertyStore;
var items = JArray.ReadFrom (reader);
foreach (var item in (IEnumerable<JToken>)items)
{
var typeName = (string)item["$type"];
if (typeName != null) {
var type = ((EtoBinder)serializer.Binder).BindToType (typeName);
if (type != null) {
foreach (var prop in (IDictionary<string, JToken>)item) {
if (prop.Key == "$type") continue;
var memberName = "Set" + prop.Key;
var member = type.GetMethod(memberName, BindingFlags.Static | BindingFlags.Public);
if (member == null)
throw new JsonSerializationException(string.Format ("Could not find attachable property {0}.{1}", type.Name, memberName));
var parameters = member.GetParameters();
if (parameters.Length != 2)
throw new JsonSerializationException("Invalid number of parameters");
var propType = parameters[1].ParameterType;
using (var propReader = new JTokenReader(prop.Value)) {
var propValue = serializer.Deserialize(propReader, propType);
member.Invoke (null, new object[] { store.Parent, propValue });
}
}
}
}
}
return existingValue;
}
public override void WriteJson(Newtonsoft.Json.JsonWriter writer, object value, JsonSerializer serializer)
{
ListItemCollection items = value as ListItemCollection;
if (items.Count == 0)
{
writer.WriteRawValue("Ext.data.StoreManager.getArrayStore(2)");
return;
}
StringBuilder sb = new StringBuilder("[");
if (items != null && items.Count > 0)
{
foreach (ListItem item in items)
{
sb.Append("[");
string val = item.Value.IsEmpty() ? item.Text : item.Value;
sb.Append(item.Mode == ParameterMode.Value ? JSON.Serialize(val) : val);
sb.Append(",");
sb.Append(item.Text.IsEmpty() ? JSON.Serialize(item.Value) : JSON.Serialize(item.Text));
sb.Append("],");
}
sb.Remove(sb.Length - 1, 1);
}
sb.Append("]");
writer.WriteRawValue(sb.ToString());
}
public override bool Evaluate(Newtonsoft.Json.Linq.JObject jobject)
{
ActualLength = 0;
if (null == PropertyName) return false;
if (null == jobject) return false;
var value = jobject[PropertyName];
if (value == null)
{
return false;
}
if (value.Type.ToString() == "Null")
{
return false;
}
var length = value.ToString().Length;
bool result = false;
result = (length > MinimumLength);
ActualLength = length;
return result;
}
static void stream_OnNewJsonObject(Newtonsoft.Json.Linq.JObject obj)
{
counter++;
var user = obj["user"];
if (user != null)
{
string screenname = (string)user["screen_name"];
foreach (var mention in obj["entities"]["user_mentions"])
{
string mention_screenname = (string)mention["screen_name"];
if (screenname != null && mention_screenname != null)
{
Vertex v1 = null, v2 = null;
if (!network.ContainsVertex(screenname))
v1 = network.CreateVertex(screenname);
else
v1 = network.SearchVertex(screenname);
if (!network.ContainsVertex(mention_screenname))
v2 = network.CreateVertex(mention_screenname);
else
v2 = network.SearchVertex(mention_screenname);
if (!v1.IsPredecessor(v2))
network.CreateEdge(v1, v2, EdgeType.Undirected);
}
}
}
Console.WriteLine("Collected {0} tweets ...", counter);
}
public override object ReadJson(Newtonsoft.Json.JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
var obj = JToken.ReadFrom(reader);
var id = (string)obj;
var binder = serializer.Binder as EtoBinder;
if (binder != null)
{
var instance = binder.Instance;
if (instance != null)
{
var instanceType = instance.GetType();
var property = instanceType.GetRuntimeProperties().FirstOrDefault(r => r.Name == id);
if (property != null)
return new Info
{
PropertyInfo = property,
Instance = instance
};
var field = instanceType.GetRuntimeFields().FirstOrDefault(r => r.Name == id);
if (field != null)
return new Info
{
FieldInfo = field,
Instance = instance
};
}
}
return null;
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, Newtonsoft.Json.JsonSerializer serializer)
{
switch (reader.TokenType)
{
case JsonToken.Null:
return null;
case JsonToken.String:
string json = reader.Value.ToString();
if (String.Equals(json, "latest"))
{
return DefaultBlock.Latest;
}
else if (String.Equals(json, "pending"))
{
return DefaultBlock.Pending;
}
else if (String.Equals(json, "earliest"))
{
return DefaultBlock.Earliest;
}
else
{
return new DefaultBlock(EthHex.HexStringToInt(json));
}
default:
throw new JsonSerializationException("Unknown token type");
}
}
private static JsonSchema ParseV3OrV4Schema(string key, string jsonSchema, IDictionary<string, string> warnings,
ref Newtonsoft.JsonV4.Schema.JsonSchema v4Schema, IDictionary<string, ApiObject> objects)
{
JsonSchema schema = null;
try
{
schema = JsonSchema.Parse(jsonSchema, new JsonSchemaCustomResolver(objects));
}
catch (Exception exv3) // NewtonJson does not support Json Schema v4
{
try
{
schema = null;
v4Schema = Newtonsoft.JsonV4.Schema.JsonSchema.Parse(jsonSchema, new JsonSchemaCustomV4Resolver(objects));
}
catch (Exception exv4)
{
if (!warnings.ContainsKey(key))
warnings.Add(key,
"Could not parse JSON Schema. v3 parser message: " +
exv3.Message.Replace("\r\n", string.Empty).Replace("\n", string.Empty) +
". v4 parser message: " +
exv4.Message.Replace("\r\n", string.Empty).Replace("\n", string.Empty));
}
}
return schema;
}
public override void WriteJson(Newtonsoft.Json.JsonWriter writer, object value, Newtonsoft.Json.JsonSerializer serializer)
{
if (value != null)
writeConverter.WriteJson(writer, baseDate.Add((TimeSpan)value), serializer);
else
writeConverter.WriteJson(writer, value, serializer);
}
/// <summary>
/// Writes the JSON representation of the object.
/// </summary>
/// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
/// <param name="value">The value.</param>
/// <param name="serializer">Serializer</param>
public override void WriteJson(Newtonsoft.Json.JsonWriter writer, object value, JsonSerializer serializer)
{
string text;
if (value is DateTime || value is DateTime?)
{
DateTime dateTime = value is DateTime ? (DateTime)value : (value as DateTime?).Value;
if ((dateTimeStyles & DateTimeStyles.AdjustToUniversal) == DateTimeStyles.AdjustToUniversal
|| (dateTimeStyles & DateTimeStyles.AssumeUniversal) == DateTimeStyles.AssumeUniversal)
{
dateTime = dateTime.ToUniversalTime();
}
text = dateTime.ToString(ISODateTimeJsonConverter.DateTimeFormat, CultureInfo.InvariantCulture);
}
else
{
DateTimeOffset dateTimeOffset = (DateTimeOffset)value;
if ((dateTimeStyles & DateTimeStyles.AdjustToUniversal) == DateTimeStyles.AdjustToUniversal
|| (dateTimeStyles & DateTimeStyles.AssumeUniversal) == DateTimeStyles.AssumeUniversal)
dateTimeOffset = dateTimeOffset.ToUniversalTime();
text = dateTimeOffset.ToString(DateTimeFormat, CultureInfo.InvariantCulture);
}
writer.WriteValue(text);
}
public override void WriteJson(Newtonsoft.Json.JsonWriter writer, object value, JsonSerializer serializer)
{
if (value is string)
{
writer.WriteRawValue(new JFunction(TokenUtils.ParseTokens((string)value, false, this.Owner is Control ? (Control)this.Owner : null)).ToScript());
}
}
