private static string ReadType(JsonReader reader)
{
reader.Read();
string type = (string)reader.Value;
reader.Read();
return type;
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
if (reader.TokenType != JsonToken.StartObject)
throw new JsonException("Expected {");
var results = new List<InputAlias>();
reader.Read();
while (reader.TokenType != JsonToken.EndObject)
{
if (reader.TokenType != JsonToken.PropertyName)
throw new JsonException("Expected property name");
var alias = (string)reader.Value;
reader.Read();
if (reader.TokenType != JsonToken.String)
throw new JsonException("Expected string");
var value = (string)reader.Value;
results.Add(new InputAlias
{
Name = alias,
Value = value
});
reader.Read();
}
return results.ToArray();
}
public IConfigureCloudQueueMessageEnvelope Read(JsonReader reader)
{
if (reader == null) throw new ArgumentNullException("reader");
IConfigureCloudQueueMessageEnvelope envelope = new CloudQueueMessageEnvelope();
reader.Read(); //StartObject
reader.Read(); //PropertyName:From
envelope = envelope.SetFrom(reader.ReadAsString()); //String:From value
reader.Read(); //PropertyName:To
envelope = envelope.SetTo(reader.ReadAsString()); //String:To value
reader.Read(); //PropertyName:MessageId
envelope = envelope.SetMessageId(new Guid(reader.ReadAsString())); //String:MessageId value
reader.Read();
if (((string)reader.Value) == "RelatesToMessageId") //PropertyName:Possibly RelatesToMessageId
{
envelope = envelope.SetRelatesToMessageId(new Guid(reader.ReadAsString()));
reader.Read(); //PropertyName:CorrelationId
}
envelope = envelope.SetCorrelationId(new Guid(reader.ReadAsString())); //String:CorrelationId value
reader.Read(); //PropertyName:ContentType
envelope = envelope.SetContentType(reader.ReadAsString()); //String:ContentType value
reader.Read(); //PropertyName:Content
envelope = envelope.SetContent(reader.ReadAsBytes()); //String:Content value
reader.Read(); //PropertyName:Time
envelope = envelope.SetTime(reader.ReadAsDateTimeOffset().GetValueOrDefault()); //String:Time value
reader.Read(); //EndObject
return envelope;
}
/// <summary>
/// Invoked when caller's data has to be deserialized.
/// </summary>
/// <returns>The DateTimeOffset converted to UTC time.
/// In this case the offset value is allways 0.</returns>
public override object ReadJson(Newtonsoft.Json.JsonReader reader,
Type objectType, object existingValue,
Newtonsoft.Json.JsonSerializer serializer)
{
if (objectType == typeof(DateTime))
{
//SEE HERE WHY.
throw new NotSupportedException("DateTime not allowed");
}
else if (objectType == typeof(DateTimeOffset))
{
reader.Read(); // move to datetime element
reader.Read(); //move to datetime value
DateTime dt = (DateTime)reader.Value;
reader.Read(); // move to offset element
reader.Read(); //move to offset value
Int64 offsetinMin = (Int64)reader.Value;
DateTime utcTime = new DateTime(dt.AddMinutes(-offsetinMin).Ticks,
DateTimeKind.Utc);
reader.Read();//ensures that reader is left in valid state.
return(new DateTimeOffset(utcTime, TimeSpan.FromMinutes(0)));
}
else
{
return(null);
}
}
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, JsonSerializer serializer)
{
var itemType = objectType.GenericTypeArguments.Single();
if (reader.TokenType == JsonToken.StartObject)
{
object itemsArray = null;
LimitsReturned limitsReturned = null;
while (reader.Read())
{
if (reader.TokenType == JsonToken.StartArray)
{
//Items Array
itemsArray = serializer.Deserialize(reader, itemType.MakeArrayType());
}
else if (reader.TokenType == JsonToken.PropertyName && ((string)reader.Value).Equals("limits", StringComparison.OrdinalIgnoreCase))
{
reader.Read();
limitsReturned = serializer.Deserialize<LimitsReturned>(reader);
}
}
if (limitsReturned == null)
{
throw new InvalidOperationException("Limits nicht gefunden!");
}
return Activator.CreateInstance(objectType, itemsArray, limitsReturned);
}
throw new InvalidOperationException("Der JsonReader muss auf einem Objekt stehen!");
}
private object ProcessToken(JsonReader reader)
{
// Recursively processes a token. This is required for elements that next other elements.
object processedObject = null;
if (reader.TokenType == JsonToken.StartObject)
{
Dictionary<string, object> dictionaryValue = new Dictionary<string, object>();
while (reader.Read() && reader.TokenType != JsonToken.EndObject)
{
string elementKey = reader.Value.ToString();
reader.Read();
dictionaryValue.Add(elementKey, ProcessToken(reader));
}
processedObject = dictionaryValue;
}
else if (reader.TokenType == JsonToken.StartArray)
{
List<object> arrayValue = new List<object>();
while (reader.Read() && reader.TokenType != JsonToken.EndArray)
{
arrayValue.Add(ProcessToken(reader));
}
processedObject = arrayValue.ToArray();
}
else
{
processedObject = reader.Value;
}
return processedObject;
}
private static object InternalReadJson(JsonReader reader, JsonSerializer serializer)
{
if (reader.TokenType != JsonToken.StartObject)
throw new ArgumentException("Expected token '{' not found.");
reader.Read();
AttributesTable attributesTable = new AttributesTable();
while (reader.TokenType == JsonToken.PropertyName)
{
string attributeName = (string) reader.Value;
reader.Read();
object attributeValue;
if (reader.TokenType == JsonToken.StartObject)
{
// inner object
attributeValue = InternalReadJson(reader, serializer);
}
else
{
attributeValue = reader.Value;
}
reader.Read();
attributesTable.AddAttribute(attributeName, attributeValue);
}
return attributesTable;
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
if (reader == null)
{
throw new ArgumentNullException(nameof(reader));
}
int result = 0;
// What's happening in this code? We express [Flags] enums in JSON as arrays of
// strings. On deserialization, we walk the array, locate each string,
// and convert it to its equivalent enum value. Because we don't have a strong
// sense of the destination type, we simply treat the enum values as numbers
// and OR them together. This number will eventually be unboxed and assigned
// to the target enum property.
// Read start of array
reader.Read();
while (reader.TokenType == JsonToken.String)
{
string enumName = EnumConverter.ConvertToPascalCase((string)reader.Value);
result |= (int)Enum.Parse(objectType, enumName);
reader.Read();
}
return result;
}
private static long ReadId(JsonReader reader)
{
reader.Read();
long type = (long)reader.Value;
reader.Read();
return type;
}
/// <summary>
/// Reads the JSON representation of the object.
/// </summary>
/// <param name="reader">The <see cref="Newtonsoft.Json.JsonReader"/> to read from.</param>
/// <param name="objectType">The <see cref="System.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)
{
switch(reader.TokenType)
{
case JsonToken.Integer:
return new Contributors { Id = (long)reader.Value };
case JsonToken.StartObject:
reader.Read();
var value = new Contributors();
while(reader.TokenType != JsonToken.EndObject)
{
if(reader.TokenType != JsonToken.PropertyName)
throw new FormatException("The format of this object is wrong");
switch((string)reader.Value)
{
case "id":
value.Id = (long)reader.ReadAsDecimal();
break;
case "screen_name":
value.ScreenName = reader.ReadAsString();
break;
default:
reader.Read();
break;
}
reader.Read();
}
return value;
}
throw new InvalidOperationException("This object is not a Contributors");
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
List<Sex> result = new List<Sex> ();
// now tokentype is [
reader.Read ();
while (reader.TokenType == JsonToken.String)
{
string enumString = (string)reader.Value;
switch (enumString)
{
case "man":
result.Add (Sex.Male);
break;
case "woman":
result.Add (Sex.Female);
break;
default:
throw new Exception ("Wrong sex");
}
reader.Read ();
}
return result;
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
var path = reader.Path;
const string jsonpath = "summary.total_count";
var parts = jsonpath.Split('.');
var i = 0;
object result = 0L;
while (true)
{
if (reader.TokenType == JsonToken.EndObject && reader.Path == path) break;
if (reader.TokenType == JsonToken.PropertyName &&
reader.ValueType == typeof (string) &&
(string) reader.Value == parts[i])
{
i++;
if (i == parts.Length)
{
reader.Read();
if (reader.TokenType != JsonToken.Integer) Debugger.Break();
result = reader.Value;
}
}
reader.Read();
}
return result;
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
var typeName = string.Empty;
do
{
reader.Read();
// SELF this depends on the alphabetical order of the property names and should be changed
if (reader.TokenType == JsonToken.PropertyName
&& string.Compare(reader.Value as string, "MessageTypeName", true) == 0)
{
reader.Read();
typeName = reader.Value.ToString();
}
if (reader.TokenType == JsonToken.PropertyName && string.Compare(reader.Value as string, "Payload", true) == 0)
{
reader.Read();
var type = Type.GetType(typeName);
var msg = serializer.Deserialize(reader, type);
return new Envelope(msg as IMessage);
}
}
while (reader.TokenType != JsonToken.EndObject);
reader.Read();
return null;
}
/// <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;
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
var collection = new NameValueCollection();
while (reader.Read())
{
if (reader.TokenType == JsonToken.EndObject)
break;
var key = (string)reader.Value;
if (reader.Read() == false)
throw new InvalidOperationException("Expected PropertyName, got " + reader.TokenType);
if (reader.TokenType == JsonToken.StartArray)
{
var values = serializer.Deserialize<string[]>(reader);
foreach (var value in values)
{
collection.Add(key, value);
}
}
else
{
collection.Add(key, reader.Value.ToString());
}
}
return collection;
}
public override bool MoveNext()
{
if (IsDisposed) throw new ObjectDisposedException(null);
if (_reader == null)
{
var wc = new WebClient();
//var json = wc.DownloadString("http://data.baltimorecity.gov/api/views/ijfz-2v3c/rows.json");
//var json = wc.DownloadString("file:///C:/Users/PTying/Documents/GitHub/civilsalary/civilsalary.datasync/usa/md/baltimorecity/rows.json");
var uri = new Uri((new FileInfo("..\\..\\..\\civilsalary.datasync\\usa\\md\\baltimorecity\\rows.json")).FullName);
var json = wc.DownloadString(uri);
_reader = new JsonTextReader(new StringReader(json));
_reader.ReadToProperty("meta", 1);
_reader.ReadToProperty("view", 3);
_reader.Read(); //start view object...
_view = JObject.Load(_reader).AsDynamic();
_reader.ReadToProperty("data", 1);
_reader.Read(); //step in to data
}
if (_reader.Read() && _reader.Depth == DataDepth)
{
var currentValues = JArray.Load(_reader);
_current = new EmployeeData()
{
DepartmentName = ((string)currentValues[ColumnIndex("agency")]).Trim(),
DepartmentKey = ((string)currentValues[ColumnIndex("agency")]).Trim().ToUrlValue(),
Row = new EmployeeRow()
{
GovernmentKey = _government,
Name = ((string)currentValues[ColumnIndex("name")]).Trim().Trim(','),
EmployeeId = ((string)currentValues[ColumnIndex("id")]).Trim(),
Position = ((string)currentValues[ColumnIndex("jobtitle")]).Trim(),
Salary = double.Parse((string)currentValues[ColumnIndex("annualsalary")], NumberStyles.AllowCurrencySymbol
| NumberStyles.AllowDecimalPoint
| NumberStyles.AllowLeadingSign
| NumberStyles.AllowParentheses
| NumberStyles.AllowThousands),
GrossPay = double.Parse((string)currentValues[ColumnIndex("grosspay")], NumberStyles.AllowCurrencySymbol
| NumberStyles.AllowDecimalPoint
| NumberStyles.AllowLeadingSign
| NumberStyles.AllowParentheses
| NumberStyles.AllowThousands),
HireDate = (string)currentValues[ColumnIndex("hiredate")] == null ? (DateTime?)null : DateTime.Parse((string)currentValues[ColumnIndex("hiredate")])
}
};
return true;
}
else
{
return false;
}
}
private TypeReference ReadObject(JsonReader reader)
{
reader.Read();
if (reader.TokenType != JsonToken.PropertyName || ((string)reader.Value != "__ref__" && (string)reader.Value != "type"))
{
throw new ArgumentException("Unexpected token type " + reader.TokenType);
}
var isRef = (string) reader.Value == "__ref__";
reader.Read();
if (reader.TokenType != JsonToken.String)
{
throw new ArgumentException("Unexpected token type " + reader.TokenType);
}
var retval = new TypeReference
{
IsReference = isRef,
Name = (string)reader.Value
};
reader.Read();
return retval;
}
/// <summary>
/// Reads the JSON.
/// </summary>
/// <param name="reader">The reader.</param>
/// <param name="objectType">Type of the object.</param>
/// <param name="existingValue">The existing value.</param>
/// <param name="serializer">The serializer.</param>
/// <returns></returns>
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
if (reader.TokenType == JsonToken.Null)
{
return null;
}
if (reader.TokenType != JsonToken.StartArray)
{
return null;
}
reader.Read();
var coords = new double[2];
if (reader.TokenType == JsonToken.Float || reader.TokenType == JsonToken.Integer)
{
coords[0] = (double)reader.Value;
reader.Read();
}
if (reader.TokenType == JsonToken.Float || reader.TokenType == JsonToken.Integer)
{
coords[1] = (double)reader.Value;
reader.Read();
}
var latitude = coords[0];
var longitude = coords[1];
return new TwitterGeoLocation.GeoCoordinates { Latitude = latitude, Longitude = longitude };
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
var filter = new TermsQueryDescriptor<object>();
ITermsQuery f = filter;
if (reader.TokenType != JsonToken.StartObject)
return null;
var depth = reader.Depth;
while (reader.Read() && reader.Depth >= depth && reader.Value != null)
{
var property = reader.Value as string;
switch (property)
{
case "boost":
reader.Read();
f.Boost = reader.Value as double?;
break;
case "_name":
f.Name = reader.ReadAsString();
break;
default:
f.Field = property;
//reader.Read();
ReadTerms(f, reader, serializer);
//reader.Read();
break;
}
}
return filter;
}
/// <summary>
/// 解析json字段的值;
/// </summary>
/// <param name="reader"></param>
/// <param name="serializer"></param>
/// <returns></returns>
private object CreateJsonValue(Newtonsoft.Json.JsonReader reader, Newtonsoft.Json.JsonSerializer serializer)
{
while (reader.TokenType == Newtonsoft.Json.JsonToken.Comment)
{
if (!reader.Read())
{
throw new JsonSerializationException("Unexpected end.");
}
}
switch (reader.TokenType)
{
case JsonToken.StartObject:
{
return(CreateJsonObject(reader, serializer));
}
case JsonToken.StartArray:
{
var list = new List <object>();
while (reader.Read())
{
switch (reader.TokenType)
{
case JsonToken.EndArray:
return(list);
default:
var value = CreateJsonValue(reader, serializer);
list.Add(value);
break;
}
}
}
break;
case JsonToken.Integer:
return(System.Convert.ToInt64(reader.Value, CultureInfo.InvariantCulture));
case JsonToken.Float:
return(System.Convert.ToDouble(reader.Value, CultureInfo.InvariantCulture));
case JsonToken.Boolean:
return(System.Convert.ToBoolean(reader.Value, CultureInfo.InvariantCulture));
case JsonToken.String:
case JsonToken.Bytes:
case JsonToken.Date:
return(reader.Value.ToString());
case JsonToken.Null:
return(null);
default:
throw new JsonSerializationException("Unexpected or unsupported token: {0}" + reader.TokenType);
}
throw new JsonSerializationException("Unexpected end.");
}
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;
}
private TypeReference[] ReadArray(JsonReader reader)
{
var singleItem = ReadItem(reader);
if (singleItem != null)
{
return new[] { singleItem };
}
if (reader.TokenType != JsonToken.StartArray)
{
throw new ArgumentException("Unexpected token type " + reader.TokenType);
}
var tokens = new List<TypeReference>();
reader.Read();
while (reader.TokenType != JsonToken.EndArray)
{
singleItem = ReadItem(reader);
if (singleItem != null)
{
tokens.Add(singleItem);
reader.Read();
continue;
}
throw new ArgumentException("Unexpected token type " + reader.TokenType);
}
return tokens.ToArray();
}
/// <inheritdoc/>
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
bool isRoot = reader.Depth == 0;
if (isRoot)
{
// Skip to the desired property
while (reader.Read())
{
if (reader.TokenType != JsonToken.PropertyName || reader.Value.ToString() != _name)
continue;
// Advance to the contained value
reader.Read();
break;
}
}
// Default Deserialization
object result = base.ReadJson(reader, objectType, existingValue, serializer);
if (isRoot)
{
while (reader.Read()) { } // Advance to end
}
return result;
}
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 };
}
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;
}
private object ReadObject(JsonReader reader)
{
var obj = new Dictionary<string, object>();
while (reader.Read())
{
switch (reader.TokenType)
{
case JsonToken.PropertyName:
var propertyName = reader.Value.ToString();
if (!reader.Read())
{
throw new JsonSerializationException("Unexpected end when reading IDictionary<string, object>");
}
var value = ReadValue(reader);
obj[propertyName] = value;
break;
case JsonToken.Comment:
break;
case JsonToken.EndObject:
return obj;
}
}
throw new JsonSerializationException("Unexpected end when reading IDictionary<string, object>");
}
/// <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)
{
var result = new Collection<Claim>();
while (reader.Read())
{
if (reader.TokenType == JsonToken.EndArray)
break;
if (reader.TokenType != JsonToken.StartObject)
continue;
var jo = JObject.Load(reader);
var claim = new Claim(
(string)jo["ClaimType"],
(string)jo["Value"],
(string)jo["ValueType"],
(string)jo["Issuer"],
(string)jo["OriginalIssuer"]
);
var jt = jo["Properties"];
var props = serializer.Deserialize<Dictionary<string, string>>(jt.CreateReader());
foreach (var entry in props)
claim.Properties.Add(entry.Key, entry.Value);
result.Add(claim);
}
// Reading EndObject;
reader.Read();
return result;
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
if (ReflectionUtils.IsNullableType(objectType))
Nullable.GetUnderlyingType(objectType);
if (reader.TokenType == JsonToken.Null)
{
if (!ReflectionUtils.IsNullable(objectType))
throw JsonSerializationException.Create(reader, StringUtils.FormatWith("Cannot convert null value to {0}.", (IFormatProvider) CultureInfo.InvariantCulture, (object) objectType));
else
return (object) null;
}
else
{
if (reader.TokenType != JsonToken.StartConstructor || !string.Equals(reader.Value.ToString(), "Date", StringComparison.Ordinal))
throw JsonSerializationException.Create(reader, StringUtils.FormatWith("Unexpected token or value when parsing date. Token: {0}, Value: {1}", (IFormatProvider) CultureInfo.InvariantCulture, (object) reader.TokenType, reader.Value));
reader.Read();
if (reader.TokenType != JsonToken.Integer)
throw JsonSerializationException.Create(reader, StringUtils.FormatWith("Unexpected token parsing date. Expected Integer, got {0}.", (IFormatProvider) CultureInfo.InvariantCulture, (object) reader.TokenType));
DateTime dateTime = JsonConvert.ConvertJavaScriptTicksToDateTime((long) reader.Value);
reader.Read();
if (reader.TokenType != JsonToken.EndConstructor)
throw JsonSerializationException.Create(reader, StringUtils.FormatWith("Unexpected token parsing date. Expected EndConstructor, got {0}.", (IFormatProvider) CultureInfo.InvariantCulture, (object) reader.TokenType));
else
return (object) dateTime;
}
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
var singleItem = ReadItem(reader);
if (singleItem != null)
{
return new[] { singleItem };
}
if (reader.TokenType != JsonToken.StartArray)
{
throw new ArgumentException("Unexpected token type " + reader.TokenType);
}
var tokens = new List<TypeReference>();
reader.Read();
while (reader.TokenType != JsonToken.EndArray)
{
singleItem = ReadItem(reader);
if (singleItem != null)
{
tokens.Add(singleItem);
reader.Read();
continue;
}
throw new ArgumentException("Unexpected token type " + reader.TokenType);
}
return tokens.ToArray();
}
//get the current account balance for a given user
public string getAccountBalance(string username, string apiKey, ref NotifyIcon notifyIcon)
{
string accountBalance = "0.0";
try
{
if (String.IsNullOrEmpty(username))
return "";
WebClient client = new WebClient();
string urlFormat = "http://marketplace.envato.com/api/v1/" + username + "/" + apiKey + "/account.json";
Uri url = new Uri(string.Format(urlFormat));
string data = client.DownloadString(url);
using (JsonReader reader = new JsonReader(new StringReader(data)))
{
while (reader.Read())
{
//users++;
if ((string)reader.Value == "balance")
{
reader.Read();
accountBalance = (string)reader.Value;
}
}
reader.Close(); //close the reader object
}
}
catch (WebException webex)
{
notifyIcon.ShowBalloonTip(180000000, "EnvatoTracker error!", "Error querying the api - invalid api key maybe?\n\nError:"+webex, ToolTipIcon.None);
}
return accountBalance;
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
if (reader.TokenType == JsonToken.String)
{
var ret = LogLevel.FromString((string)reader.Value);
return ret;
}
else if (reader.TokenType == JsonToken.StartObject)
{
reader.Read();
if (reader.TokenType == JsonToken.PropertyName && String.Equals((string)reader.Value, "name", StringComparison.OrdinalIgnoreCase))
{
reader.Read();
if (reader.TokenType == JsonToken.String)
{
string val = (string)reader.Value;
reader.Read();
Debug.Assert(reader.TokenType == JsonToken.EndObject);
return LogLevel.FromString(val);
}
}
}
return null;
}
/// <summary>
/// 递归创建对象;
/// </summary>
/// <param name="reader"></param>
/// <param name="serializer"></param>
/// <returns></returns>
private object CreateJsonObject(Newtonsoft.Json.JsonReader reader, JsonSerializer serializer)
{
var dict = new Dictionary <string, object>();
string propertyName = null;
while (reader.Read())
{
switch (reader.TokenType)
{
case JsonToken.PropertyName:
propertyName = (string)reader.Value;
break;
case JsonToken.EndObject:
return(dict);
case JsonToken.Comment:
break;
default:
var propertyValue = CreateJsonValue(reader, serializer);
dict[propertyName] = propertyValue;
break;
}
}
throw new JsonSerializationException("Unexpected end.");
}
// Returns an iterable that yields JSON objects from the structure given in the regex. In this case [ { obj1 }, { obj2 } ]
public static IEnumerable <T> SelectTokensWithRegex <T>(
this Newtonsoft.Json.JsonReader jsonReader, Regex regex)
{
JsonSerializer serializer = new JsonSerializer();
while (jsonReader.Read())
{
if (regex.IsMatch(jsonReader.Path) &&
jsonReader.TokenType != JsonToken.PropertyName)
{
yield return(serializer.Deserialize <T>(jsonReader));
}
}
}
public override object ReadJson(Newtonsoft.Json.JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
if (reader.TokenType == JsonToken.None)
{
reader.Read();
}
var value = CreateJsonValue(reader, serializer);
if (value == null)
{
return(null);
}
if (!objectType.IsInstanceOfType(value))
{
throw new JsonSerializationException(string.Format("Could not convert '{0}' to '{1}'.", value.GetType(), objectType));
}
return(value);
}
public override object ReadJson(Newtonsoft.Json.JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
if (objectType != typeof(XmlDocument))
{
throw new JsonSerializationException("XmlNodeConverter only supports deserializing XmlDocuments");
}
XmlDocument document = new XmlDocument();
XmlNamespaceManager manager = new XmlNamespaceManager(document.NameTable);
if (reader.TokenType != JsonToken.StartObject)
{
throw new JsonSerializationException("XmlNodeConverter can only convert JSON that begins with an object.");
}
reader.Read();
DeserializeNode(reader, document, manager, document);
return(document);
}
private void DeserializeNode(Newtonsoft.Json.JsonReader reader, XmlDocument document, XmlNamespaceManager manager, XmlNode currentNode)
{
if (currentNode.NodeType == XmlNodeType.Document)
{
XmlElement root = document.CreateElement("records");
document.AppendChild(root);
currentNode = root;
}
XmlNode savedNode = currentNode;
do
{
if (savedNode.Name == "records" && savedNode.ParentNode.NodeType == XmlNodeType.Document)
{
currentNode = savedNode;
}
switch (reader.TokenType)
{
case JsonToken.PropertyName:
if (currentNode.NodeType == XmlNodeType.Document && document.DocumentElement != null)
{
throw new JsonSerializationException("JSON root object has multiple properties. The root object must have a single property in order to create a valid XML document.");
}
string propertyName = reader.Value.ToString();
reader.Read();
if (reader.TokenType == JsonToken.StartArray)
{
while (reader.Read() && reader.TokenType != JsonToken.EndArray)
{
if (reader.TokenType == JsonToken.StartObject)
{
if (currentNode.Name == "records" && currentNode.ParentNode.NodeType == XmlNodeType.Document &&
(propertyName == "Updated" || propertyName == "Created" || propertyName == "Deleted"))
{
XmlNode tempNode = currentNode.SelectSingleNode(propertyName);
if (tempNode != null)
{
currentNode = tempNode;
propertyName = "record";
}
}
}
DeserializeValue(reader, document, manager, propertyName, currentNode);
}
}
else
{
bool addRecord = currentNode.ParentNode != null && currentNode.ParentNode.ParentNode != null &&
currentNode.ParentNode.Name == "records" && currentNode.ParentNode.ParentNode.NodeType == XmlNodeType.Document;
if ((currentNode.Name == "Updated" || currentNode.Name == "Created" || currentNode.Name == "Deleted") && addRecord)
{
XmlElement record = document.CreateElement("record");
currentNode.AppendChild(record);
currentNode = record;
}
DeserializeValue(reader, document, manager, propertyName, currentNode);
}
break;
case JsonToken.StartConstructor:
string constructorName = reader.Value.ToString();
while (reader.Read() && reader.TokenType != JsonToken.EndConstructor)
{
DeserializeValue(reader, document, manager, "-" + constructorName, currentNode);
}
break;
case JsonToken.EndObject:
case JsonToken.EndArray:
return;
default:
throw new JsonSerializationException("Unexpected JsonToken when deserializing node: " + reader.TokenType);
}
} while (reader.TokenType == JsonToken.PropertyName || reader.Read());
// don't read if current token is a property. token was already read when parsing element attributes
}
internal void WriteToken(JsonReader reader, int initialDepth)
{
while (true)
{
switch (reader.TokenType)
{
case JsonToken.None:
goto IL_1DB;
case JsonToken.StartObject:
this.WriteStartObject();
goto IL_1DB;
case JsonToken.StartArray:
this.WriteStartArray();
goto IL_1DB;
case JsonToken.StartConstructor:
{
string text = reader.Value.ToString();
if (string.Compare(text, "Date", 4) == 0)
{
this.WriteConstructorDate(reader);
}
else
{
this.WriteStartConstructor(reader.Value.ToString());
}
goto IL_1DB;
}
case JsonToken.PropertyName:
this.WritePropertyName(reader.Value.ToString());
goto IL_1DB;
case JsonToken.Comment:
this.WriteComment(reader.Value.ToString());
goto IL_1DB;
case JsonToken.Raw:
this.WriteRawValue((string)reader.Value);
goto IL_1DB;
case JsonToken.Integer:
this.WriteValue(Convert.ToInt64(reader.Value, CultureInfo.get_InvariantCulture()));
goto IL_1DB;
case JsonToken.Float:
this.WriteValue(Convert.ToDouble(reader.Value, CultureInfo.get_InvariantCulture()));
goto IL_1DB;
case JsonToken.String:
this.WriteValue(reader.Value.ToString());
goto IL_1DB;
case JsonToken.Boolean:
this.WriteValue(Convert.ToBoolean(reader.Value, CultureInfo.get_InvariantCulture()));
goto IL_1DB;
case JsonToken.Null:
this.WriteNull();
goto IL_1DB;
case JsonToken.Undefined:
this.WriteUndefined();
goto IL_1DB;
case JsonToken.EndObject:
this.WriteEndObject();
goto IL_1DB;
case JsonToken.EndArray:
this.WriteEndArray();
goto IL_1DB;
case JsonToken.EndConstructor:
this.WriteEndConstructor();
goto IL_1DB;
case JsonToken.Date:
this.WriteValue((DateTime)reader.Value);
goto IL_1DB;
case JsonToken.Bytes:
this.WriteValue((byte[])reader.Value);
goto IL_1DB;
}
break;
IL_1DB:
if (initialDepth - 1 >= reader.Depth - ((!this.IsEndToken(reader.TokenType)) ? 0 : 1) || !reader.Read())
{
return;
}
}
throw MiscellaneousUtils.CreateArgumentOutOfRangeException("TokenType", reader.TokenType, "Unexpected token type.");
}
internal void WriteToken(JsonReader reader, int initialDepth)
{
do
{
switch (reader.TokenType)
{
case JsonToken.StartObject:
WriteStartObject();
break;
case JsonToken.StartArray:
WriteStartArray();
break;
case JsonToken.StartConstructor:
{
string strA = reader.Value.ToString();
if (string.Compare(strA, "Date", StringComparison.Ordinal) == 0)
{
WriteConstructorDate(reader);
}
else
{
WriteStartConstructor(reader.Value.ToString());
}
break;
}
case JsonToken.PropertyName:
WritePropertyName(reader.Value.ToString());
break;
case JsonToken.Comment:
WriteComment(reader.Value.ToString());
break;
case JsonToken.Integer:
WriteValue(Convert.ToInt64(reader.Value, CultureInfo.InvariantCulture));
break;
case JsonToken.Float:
WriteValue(Convert.ToDouble(reader.Value, CultureInfo.InvariantCulture));
break;
case JsonToken.String:
WriteValue(reader.Value.ToString());
break;
case JsonToken.Boolean:
WriteValue(Convert.ToBoolean(reader.Value, CultureInfo.InvariantCulture));
break;
case JsonToken.Null:
WriteNull();
break;
case JsonToken.Undefined:
WriteUndefined();
break;
case JsonToken.EndObject:
WriteEndObject();
break;
case JsonToken.EndArray:
WriteEndArray();
break;
case JsonToken.EndConstructor:
WriteEndConstructor();
break;
case JsonToken.Date:
WriteValue((DateTime)reader.Value);
break;
case JsonToken.Raw:
WriteRawValue((string)reader.Value);
break;
case JsonToken.Bytes:
WriteValue((byte[])reader.Value);
break;
default:
throw MiscellaneousUtils.CreateArgumentOutOfRangeException("TokenType", reader.TokenType, "Unexpected token type.");
case JsonToken.None:
break;
}
}while (initialDepth - 1 < reader.Depth - (IsEndToken(reader.TokenType) ? 1 : 0) && reader.Read());
}
internal void WriteToken(JsonReader reader, int initialDepth)
{
do
{
switch (reader.TokenType)
{
case JsonToken.None:
// read to next
break;
case JsonToken.StartObject:
WriteStartObject();
break;
case JsonToken.StartArray:
WriteStartArray();
break;
case JsonToken.StartConstructor:
string constructorName = reader.Value.ToString();
// write a JValue date when the constructor is for a date
if (string.Compare(constructorName, "Date", StringComparison.Ordinal) == 0)
{
WriteConstructorDate(reader);
}
else
{
WriteStartConstructor(reader.Value.ToString());
}
break;
case JsonToken.PropertyName:
WritePropertyName(reader.Value.ToString());
break;
case JsonToken.Comment:
WriteComment(reader.Value.ToString());
break;
case JsonToken.Integer:
WriteValue((long)reader.Value);
break;
case JsonToken.Float:
WriteValue((double)reader.Value);
break;
case JsonToken.String:
WriteValue(reader.Value.ToString());
break;
case JsonToken.Boolean:
WriteValue((bool)reader.Value);
break;
case JsonToken.Null:
WriteNull();
break;
case JsonToken.Undefined:
WriteUndefined();
break;
case JsonToken.EndObject:
WriteEndObject();
break;
case JsonToken.EndArray:
WriteEndArray();
break;
case JsonToken.EndConstructor:
WriteEndConstructor();
break;
case JsonToken.Date:
WriteValue((DateTime)reader.Value);
break;
case JsonToken.Raw:
WriteRawValue((string)reader.Value);
break;
case JsonToken.Bytes:
WriteValue((byte[])reader.Value);
break;
default:
throw MiscellaneousUtils.CreateArgumentOutOfRangeException("TokenType", reader.TokenType, "Unexpected token type.");
}
}while (
// stop if we have reached the end of the token being read
initialDepth - 1 < reader.Depth - (IsEndToken(reader.TokenType) ? 1 : 0) &&
reader.Read());
}
/// <summary>
/// Reads the next JSON token from the stream.
/// </summary>
/// <returns>
/// true if the next token was read successfully; false if there are no more tokens to read.
/// </returns>
public override bool Read()
{
if (!_reader.Read())
{
return(false);
}
if (_reader.TokenType == JsonToken.Comment)
{
return(true);
}
// first time Read has been called. build model
if (_model == null)
{
JsonSchemaModelBuilder builder = new JsonSchemaModelBuilder();
_model = builder.Build(_schema);
}
switch (_reader.TokenType)
{
case JsonToken.StartObject:
ProcessValue();
JsonSchemaModel objectSchema = (ValidateObject(CurrentMemberSchema))
? CurrentMemberSchema
: null;
Push(new SchemaScope(JTokenType.Object, objectSchema));
break;
case JsonToken.StartArray:
ProcessValue();
JsonSchemaModel arraySchema = (ValidateArray(CurrentMemberSchema))
? CurrentMemberSchema
: null;
Push(new SchemaScope(JTokenType.Array, arraySchema));
break;
case JsonToken.StartConstructor:
Push(new SchemaScope(JTokenType.Constructor, null));
break;
case JsonToken.PropertyName:
ValidatePropertyName(CurrentSchema);
break;
case JsonToken.Raw:
break;
case JsonToken.Integer:
ProcessValue();
ValidateInteger(CurrentMemberSchema);
break;
case JsonToken.Float:
ProcessValue();
ValidateFloat(CurrentMemberSchema);
break;
case JsonToken.String:
ProcessValue();
ValidateString(CurrentMemberSchema);
break;
case JsonToken.Boolean:
ProcessValue();
ValidateBoolean(CurrentMemberSchema);
break;
case JsonToken.Null:
ProcessValue();
ValidateNull(CurrentMemberSchema);
break;
case JsonToken.Undefined:
break;
case JsonToken.EndObject:
ValidateEndObject(CurrentSchema);
Pop();
break;
case JsonToken.EndArray:
ValidateEndArray(CurrentSchema);
Pop();
break;
case JsonToken.EndConstructor:
Pop();
break;
case JsonToken.Date:
break;
default:
throw new ArgumentOutOfRangeException();
}
return(true);
}
private void DeserializeValue(Newtonsoft.Json.JsonReader reader, XmlDocument document, XmlNamespaceManager manager, string propertyName, XmlNode currentNode)
{
// deserialize xml element
bool finishedAttributes = false;
bool finishedElement = false;
Dictionary <string, string> attributeNameValues = new Dictionary <string, string>();
// a string token means the element only has a single text child
if (reader.TokenType != JsonToken.String &&
reader.TokenType != JsonToken.Null &&
reader.TokenType != JsonToken.Boolean &&
reader.TokenType != JsonToken.Integer &&
reader.TokenType != JsonToken.Float &&
reader.TokenType != JsonToken.Date &&
reader.TokenType != JsonToken.StartConstructor)
{
// read properties until first non-attribute is encountered
while (!finishedAttributes && !finishedElement && reader.Read())
{
switch (reader.TokenType)
{
case JsonToken.PropertyName:
string attributeName = reader.Value.ToString();
if (attributeName[0] == '@')
{
attributeName = attributeName.Substring(1);
reader.Read();
string attributeValue = reader.Value.ToString();
attributeNameValues.Add(attributeName, attributeValue);
}
else
{
finishedAttributes = true;
}
break;
case JsonToken.EndObject:
finishedElement = true;
break;
default:
throw new JsonSerializationException("Unexpected JsonToken: " + reader.TokenType);
}
}
}
// have to wait until attributes have been parsed before creating element
// attributes may contain namespace info used by the element
XmlElement element = document.CreateElement(propertyName);
currentNode.AppendChild(element);
// add attributes to newly created element
foreach (KeyValuePair <string, string> nameValue in attributeNameValues)
{
XmlAttribute attribute = document.CreateAttribute(nameValue.Key);
attribute.Value = nameValue.Value;
element.SetAttributeNode(attribute);
}
if (reader.TokenType == JsonToken.String)
{
element.AppendChild(document.CreateTextNode(reader.Value.ToString()));
}
else if (reader.TokenType == JsonToken.Integer)
{
element.AppendChild(document.CreateTextNode(XmlConvert.ToString((long)reader.Value)));
}
else if (reader.TokenType == JsonToken.Float)
{
element.AppendChild(document.CreateTextNode(XmlConvert.ToString((double)reader.Value)));
}
else if (reader.TokenType == JsonToken.Boolean)
{
element.AppendChild(document.CreateTextNode(XmlConvert.ToString((bool)reader.Value)));
}
else if (reader.TokenType == JsonToken.Date)
{
DateTime d = (DateTime)reader.Value;
element.AppendChild(document.CreateTextNode(XmlConvert.ToString(d, ToSerializationMode(d.Kind))));
}
else if (reader.TokenType == JsonToken.Null)
{
// empty element. do nothing
}
else
{
// finished element will have no children to deserialize
if (!finishedElement)
{
manager.PushScope();
DeserializeNode(reader, document, manager, element);
manager.PopScope();
}
}
}
internal void WriteToken(JsonReader reader, int initialDepth)
{
do
{
switch (reader.TokenType)
{
case JsonToken.None:
// read to next
break;
case JsonToken.StartObject:
WriteStartObject();
break;
case JsonToken.StartArray:
WriteStartArray();
break;
case JsonToken.StartConstructor:
string constructorName = reader.Value.ToString();
// write a JValue date when the constructor is for a date
if (string.Equals(constructorName, "Date", StringComparison.Ordinal))
{
WriteConstructorDate(reader);
}
else
{
WriteStartConstructor(reader.Value.ToString());
}
break;
case JsonToken.PropertyName:
WritePropertyName(reader.Value.ToString());
break;
case JsonToken.Comment:
WriteComment((reader.Value != null) ? reader.Value.ToString() : null);
break;
case JsonToken.Integer:
WriteValue(Convert.ToInt64(reader.Value, CultureInfo.InvariantCulture));
break;
case JsonToken.Float:
object value = reader.Value;
if (value is decimal)
{
WriteValue((decimal)value);
}
else if (value is double)
{
WriteValue((double)value);
}
else if (value is float)
{
WriteValue((float)value);
}
else
{
WriteValue(Convert.ToDouble(value, CultureInfo.InvariantCulture));
}
break;
case JsonToken.String:
WriteValue(reader.Value.ToString());
break;
case JsonToken.Boolean:
WriteValue(Convert.ToBoolean(reader.Value, CultureInfo.InvariantCulture));
break;
case JsonToken.Null:
WriteNull();
break;
case JsonToken.Undefined:
WriteUndefined();
break;
case JsonToken.EndObject:
WriteEndObject();
break;
case JsonToken.EndArray:
WriteEndArray();
break;
case JsonToken.EndConstructor:
WriteEndConstructor();
break;
case JsonToken.Date:
#if !PocketPC && !NET20
if (reader.Value is DateTimeOffset)
{
WriteValue((DateTimeOffset)reader.Value);
}
else
#endif
WriteValue(Convert.ToDateTime(reader.Value, CultureInfo.InvariantCulture));
break;
case JsonToken.Raw:
WriteRawValue((reader.Value != null) ? reader.Value.ToString() : null);
break;
case JsonToken.Bytes:
WriteValue((byte[])reader.Value);
break;
default:
throw MiscellaneousUtils.CreateArgumentOutOfRangeException("TokenType", reader.TokenType, "Unexpected token type.");
}
}while (
// stop if we have reached the end of the token being read
initialDepth - 1 < reader.Depth - (IsEndToken(reader.TokenType) ? 1 : 0) &&
reader.Read());
}
