Represents a reader that provides fast, non-cached, forward-only access to serialized Json data.
Inheritance: IDisposable
        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            JToken value = null;
            var response = new FindConnectedObjectsResponse();
            // status
            var json = JObject.ReadFrom(reader) as JObject;
            json.TryGetValue("status", out value);
            response.Status = serializer.Deserialize<Status>(value.CreateReader());
            if (response.Status.IsSuccessful == false)
                return response;
            json.Remove("status");

            // paging info
            // Extract paging info
            json.TryGetValue("paginginfo", out value);
            response.PagingInfo = serializer.Deserialize<PagingInfo>(value.CreateReader());
            json.Remove("paginginfo");

            // extract parent label
            json.TryGetValue("parent", out value);
            var parentLabel = value.ToString();

            // Extract graph node.
            json.TryGetValue("nodes", out value);
            if (value.Type != JTokenType.Null)
            {
                var nodes = value.Values<JObject>();
                ParseNodes(response, parentLabel, nodes, serializer);
            }
            else
                response.Nodes = new List<GraphNode>();
            return response;
        }
        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            string displayName = string.Empty;
            string address = string.Empty;
            while (reader.Read())
            {
                var tokenType = reader.TokenType;
                if (reader.TokenType == JsonToken.PropertyName)
                {
                    var val = (reader.Value as string )?? string.Empty;
                    if (val == "DisplayName")
                    {
                        displayName = reader.ReadAsString();
                    }
                    if (val == "Address")
                    {
                        address = reader.ReadAsString();
                    }
                }

                if (reader.TokenType == JsonToken.EndObject)
                {
                    break;
                }
            }

            var mailAddress = new MailAddress(address, displayName);
            return mailAddress;
        }
        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            var reference = SupportedTypes[objectType].Invoke();
            serializer.Populate(reader, reference);

            return reference;
        }
        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            if (reader.TokenType != JsonToken.String)
            {
                return null;
            }

            var instance = Activator.CreateInstance(objectType) as ISafeEnum;

            if (instance == null) return null;

            var enumType = objectType.GetGenericArguments()[0];
            var value = reader.Value as string;

            try
            {
                if (value == null)
                {
                    instance.Value = null;
                }
                else
                {
                    instance.Object = Enum.Parse(enumType, value, true);
                }
            }
            catch (Exception)
            {
                instance.Value = value;
            }

            return instance;
        }
 /// <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 ItemOrders();
     serializer.Converters.Add(new EmdRowCollectionJsonConverter<ItemOrders.ItemOrderEntry>());
     result.Orders = serializer.Deserialize<EmdRowCollection<ItemOrders.ItemOrderEntry>>(reader);
     return result;
 }
        //TODO: This method can be removed if we used DateTimeOffsets instead
        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            try
            {
                object o = base.ReadJson(reader, objectType, existingValue, serializer);

                //This is required because DateTime is really bad at parsing RFC1123 dates in C#.  Basically it parses the value but 
                //doesn't attach a DateTimeKind to it (even though RFC1123 specification says that the "Kind" should be UTC.  This results
                //in a DateTime WITHOUT a DateTimeKind specifier, which is bad bad bad.  We do the below in order to force the DateTimeKind
                //of the resulting DateTime to be DateTimeKind.Utc since that is what the RFC1123 specification implies.
                //See: http://stackoverflow.com/questions/1201378/how-does-datetime-touniversaltime-work
                //See: http://stackoverflow.com/questions/16442484/datetime-unspecified-kind
                DateTime? time = o as DateTime?;

                if (time.HasValue && time.Value.Kind == DateTimeKind.Unspecified)
                {
                    time = DateTime.SpecifyKind(time.Value, DateTimeKind.Utc);
                }

                return time;
            }
            catch (FormatException ex)
            {
                throw new JsonException("Unable to deserialize a Date.", ex);
            }
        }
        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            var relations = new Relations();
            
            var jToken = JToken.ReadFrom(reader);
            foreach (JProperty jProperty in jToken.Where(_ => _.GetType() == typeof(JProperty)).Cast<JProperty>())
            {
                if (jProperty.Value.GetType() == typeof (JArray))
                {
                    var links = serializer.Deserialize<Link[]>(jProperty.Value.CreateReader());
                    foreach (var link in links)
                    {
                        relations.Add(link);
                        link.Rel = jProperty.Name;
                    }
                }
                else
                {
                    var link = serializer.Deserialize<Link>(jProperty.Value.CreateReader());
                    link.Rel = jProperty.Name;
                    relations.Add(link);
                }
            }

            return relations;
        }
示例#8
0
        public static Object _ReadValue(Type ValueType, JsonReader Reader, MudObject Owner)
        {
            Object r = null;

            if (Reader.TokenType == JsonToken.String) { r = Reader.Value.ToString(); Reader.Read(); }
            else if (Reader.TokenType == JsonToken.Integer) { r = Convert.ToInt32(Reader.Value.ToString()); Reader.Read(); }
            else if (Reader.TokenType == JsonToken.Boolean) { r = Convert.ToBoolean(Reader.Value.ToString()); Reader.Read(); }
            else
            {
                PersistentValueSerializer serializer = null;
                if (ValueType != null && PersistentValueSerializer.GlobalSerializers.TryGetValue(ValueType.Name, out serializer))
                    return serializer.ReadValue(ValueType, Reader, Owner);
                else if (Reader.TokenType == JsonToken.StartObject)
                {
                    Reader.Read();
                    if (Reader.TokenType != JsonToken.PropertyName || Reader.Value.ToString() != "$type") throw new InvalidOperationException();
                    Reader.Read();
                    if (!PersistentValueSerializer.GlobalSerializers.TryGetValue(Reader.Value.ToString(), out serializer))
                        throw new InvalidOperationException();
                    Reader.Read();
                    Reader.Read();
                    r = serializer.ReadValue(ValueType, Reader, Owner);
                    Reader.Read();
                }
                else throw new InvalidOperationException();
            }
            return r;
        }
        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            var tokenArray = JToken.ReadFrom(reader);

            var children = new List<IChartOfAccountChild>();

            foreach (var token in tokenArray)
            {
                string type = token["type"].Value<string>();

                if (type == AccountGroup.typeName)
                {
                    var accountGroup = JsonConvert.DeserializeObject<AccountGroup>(token.ToString());
                    children.Add(accountGroup);
                }

                if (type == AccountIntervalGroup.typeName)
                {
                    var accountIntervalGroup = JsonConvert.DeserializeObject<AccountIntervalGroup>(token.ToString());
                    children.Add(accountIntervalGroup);
                }
            }

            return children;
        }
 public override object ReadJson(JsonReader reader, Type objectType, object existingValue,
                                 JsonSerializer serializer)
 {
     var text = reader.Value.ToString();
     //MvxTrace.Trace("About to parse {0}", text);
     return DateTime.ParseExact(text, DateTimeFormat, CultureInfo.InvariantCulture);
 }
 public override object ReadJson(JsonReader reader, Type objectType, object existingValue
     , JsonSerializer serializer)
 {
     var token = JToken.Load(reader);
     if (token.Values<string>() == null) return null;
     var list = token.Values<string>();
     var tags = new List<TagStatic>();
     foreach (var str in list)
     {
         switch (str)
         {
             case "Fighter":
                 tags.Add(TagStatic.Fighter);
                 break;
             case "Tank":
                 tags.Add(TagStatic.Tank);
                 break;
             case "Mage":
                 tags.Add(TagStatic.Mage);
                 break;
             case "Assassin":
                 tags.Add(TagStatic.Assassin);
                 break;
             case "Support":
                 tags.Add(TagStatic.Support);
                 break;
             case "Marksman":
                 tags.Add(TagStatic.Marksman);
                 break;
         }
     }
     return tags;
 }
        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;
        }
        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            if (reader.TokenType == JsonToken.Null)
            {
                return null;
            }

            List<DotaSchemaItem> leagues = new List<DotaSchemaItem>();

            JToken t = JToken.Load(reader);
            var properties = t.Children<JProperty>();
            foreach (var item in properties)
            {
                JObject o = (JObject)item.Value;

                bool isLeague = o["prefab"] != null && o["prefab"].ToString() == "league";

                bool isAdmin =
                    o["tool"] != null
                    && o["tool"]["usage"] != null
                    && o["tool"]["usage"]["admin"] != null
                    && o["tool"]["usage"]["admin"].ToString() == "1";

                if (isLeague && !isAdmin)
                {
                    var league = JsonConvert.DeserializeObject<DotaSchemaItem>(item.Value.ToString());
                    league.DefIndex = item.Name;
                    leagues.Add(league);
                }
            }

            return leagues;
        }
示例#14
0
 public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
 {
     var token = JToken.Load(reader);
     if (token.Value<string>() != null)
     {
         var str = token.Value<string>();
         switch (str)
         {
             case "CLASSIC":
                 return GameMode.Classic;
             case "ODIN":
                 return GameMode.Dominion;
             case "ARAM":
                 return GameMode.Aram;
             case "TUTORIAL":
                 return GameMode.Tutorial;
             case "ONEFORALL":
                 return GameMode.OneForAll;
             case "FIRSTBLOOD":
                 return GameMode.FirstBlood;
             case "any":
                 return GameMode.Any;
             default:
                 return null;
         }
     }
     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)
        {
            JObject jobject = JObject.Load(reader);
            object target = null;

            if (jobject != null)
            {
                var keyType = jobject["key_type"].Value<string>();

                if (string.Equals(keyType, SSHKeyType.otp.ToString(), StringComparison.OrdinalIgnoreCase))
                {
                    target = new SSHOTPRoleDefinition();
                }
                else
                {
                    if (string.Equals(keyType, SSHKeyType.dynamic.ToString(), StringComparison.OrdinalIgnoreCase))
                    {
                        target = new SSHDynamicRoleDefinition();
                    }
                }
            }

            if (target != null)
            {
                serializer.Populate(jobject.CreateReader(), target);
            }

            return target;
        }
        protected virtual object ReadJsonAsStringArray(JsonReader reader)
        {
            if (reader.TokenType != JsonToken.StartArray)
            {
                reader.Skip();
                return null;
            }

            var rowValues = new List<string>();
            var valueStartDepth = reader.Depth;
            var sb = new StringBuilder();

            using (var sw = new StringWriter(sb))
            {
                using (var jw = new JsonTextWriter(sw))
                {
                    while (reader.Read() && !(reader.TokenType == JsonToken.EndArray && reader.Depth == valueStartDepth))
                    {
                        jw.WriteToken(reader, true);
                        rowValues.Add(sb.ToString());
                        sb.Clear();
                    }
                }
            }

            return rowValues.ToArray();
        }
示例#17
0
        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            JObject jsonObject = JObject.Load(reader);

            string liteKey = (string)jsonObject["Key"];
            return Lite.Parse(liteKey);
        }
		public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
		{
			JObject o = JObject.Load(reader);
			var result = existingValue as Dictionary<string, TokenFilterBase> ?? new Dictionary<string, TokenFilterBase>();

			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().Replace("_", string.Empty);

				TokenFilterBase item;
				var itemType = Type.GetType("Nest." + typePropertyValue + "TokenFilter", false, true);
				if (itemType != null)
				{
					item = serializer.Deserialize(childProperty.Value.CreateReader(), itemType) as TokenFilterBase;
				}
				else
				{
					continue;
				}

				result[propertyName] = item;
			}
			return result;
		}
        /// <summary>
        ///   Creates a new object via the Factory.  Loads the instance via the serializer.
        /// </summary>
        /// <param name="reader">The JsonReader</param>
        /// <param name="objectType">The Type of DTO</param>
        /// <param name="existingValue">The DTO</param>
        /// <param name="serializer">JsonSerializer</param>
        /// <returns></returns>
        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            JsonReader objectReader = null;
            
            var instance = _container.CreateInstance(objectType);
            if (reader.TokenType == JsonToken.StartObject || reader.TokenType == JsonToken.StartArray)
            {
                if (reader.TokenType == JsonToken.StartObject)
                {
                    var jObject = JObject.Load(reader);
                    objectReader = jObject.CreateReader();
                }

                if (reader.TokenType == JsonToken.StartArray)
                {
                    var jArray = JArray.Load(reader);
                    objectReader = jArray.CreateReader();
                }
                
                if(objectReader != null)
                    serializer.Populate(objectReader, instance);
            }

            return instance;
        }
        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            if (reader.TokenType == JsonToken.Null)
            {
                return null;
            }

            JObject globalStatsObject = JObject.Load(reader);

            List<GlobalStat> globalStats = new List<GlobalStat>();

            foreach (var globalStatProperty in globalStatsObject.Children<JProperty>())
            {
                GlobalStat globalStat = new GlobalStat();

                globalStat.Name = globalStatProperty.Name;

                foreach (var globalStatDetailsProperty in globalStatProperty.Value.Children<JProperty>())
                {
                    string value = globalStatDetailsProperty.Value.ToString();

                    if (globalStatDetailsProperty.Name == "total") { globalStat.Total = Int32.Parse(value); }
                }

                globalStats.Add(globalStat);
            }

            return globalStats;
        }
        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            ProductStatus productStatus;
            ProductStatus.TryParse(reader.Value.ToString(), true, out productStatus);

            return productStatus;
        }
示例#22
0
        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            var obj = JObject.Load(reader);
            ProfitSharingStrategy strategy;

            var method = obj["Method"];
            if (method == null)
            {
                throw new ArgumentNullException("Type", "Order type is null");
            }

            var profitSharingMethod = (ProfitSharingMethod)Enum.Parse(typeof(ProfitSharingMethod), method.Value<string>());
            switch (profitSharingMethod)
            {
                case ProfitSharingMethod.FLAT_RATE:
                    strategy = new FlatRateStrategy();
                    break;
                case ProfitSharingMethod.PRICE_PERCENTAGE:
                    strategy = new PricePercentageStrategy();
                    break;
                default:
                    throw new NotImplementedException($"{profitSharingMethod.ToString()} is invalid/not supported");
            }

            serializer.Populate(obj.CreateReader(), strategy);
            return strategy;
        }
        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            List<ResolvedAction> resolvedActions = new List<ResolvedAction>();

            JArray actionsArray = JArray.Load(reader);
            foreach (JObject jobject in actionsArray)
            {
                ResolvedAction resolvedAction = new ResolvedAction();
                serializer.Populate(jobject.CreateReader(), resolvedAction);
                resolvedAction.BeaconAction = new BeaconAction();
                serializer.Populate(jobject.CreateReader(), resolvedAction.BeaconAction);
                if (jobject["content"] != null)
                {
                    serializer.Populate(jobject["content"]?.CreateReader(), resolvedAction.BeaconAction);
                    resolvedAction.BeaconAction.PayloadString = jobject["content"]["payload"]?.ToString();
                    // create json object for fallback
                    if(!string.IsNullOrEmpty(resolvedAction.BeaconAction.PayloadString))
                    {
                        resolvedAction.BeaconAction.Payload = JsonObject.Parse(resolvedAction.BeaconAction.PayloadString);
                    }
                }
                resolvedActions.Add(resolvedAction);
            }

            return resolvedActions;
        }
示例#24
0
        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;
        }
示例#25
0
        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) {
            if (typeof(SecureString) == objectType) {
                return ((string)reader.Value).ToSecureString();
            }

            return reader.Value;
        }
		public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
		{
			var response = new GetWarmerResponse();
			var warmersByIndex = JObject.Load(reader).Properties().ToDictionary(p => p.Name, p => p.Value);
			if (!warmersByIndex.HasAny()) return response;
			response.Indices = new Dictionary<string, Warmers>();
			foreach (var warmerByIndex in warmersByIndex)
			{
				var index = warmerByIndex.Key;
				var warmersObject = JObject.FromObject(warmerByIndex.Value).Properties()
					.Where(p => p.Name == "warmers")
					.Select(p => p.Value)
					.FirstOrDefault();
				var warmers = new Warmers();
				if (warmersObject != null)
				{
					var warmersByName = JObject.FromObject(warmersObject).Properties()
						.ToDictionary(p => p.Name, p => p.Value);
					foreach (var warmerByName in warmersByName)
					{
						var name = warmerByName.Key;
						var warmer = warmerByName.Value.ToObject<Warmer>();
						warmers.Add(name, warmer);
					}
				}
				response.Indices.Add(warmerByIndex.Key, warmers);
			}
			return response;
		}
示例#27
0
        /// <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 coordinates = serializer.Deserialize<JArray>(reader);
            if (coordinates == null || coordinates.Count != 2)
            {
                throw new ParsingException(
                    string.Format(
                        "Point geometry coordinates could not be parsed. Expected something like '[-122.428938,37.766713]' ([lon,lat]), what we received however was: {0}", 
                        coordinates));
            }

            string latitude;
            string longitude;
            try
            {
                longitude = coordinates.First.ToString();
                latitude = coordinates.Last.ToString();
            }
            catch (Exception ex)
            {
                throw new ParsingException("Could not parse GeoJSON Response. (Latitude or Longitude missing from Point geometry?)", ex);
            }

            return new List<IPosition> { new GeographicPosition(latitude, longitude) };
        }
		public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
		{
			var j = JObject.Load(reader);
			if (j == null || !j.HasValues)
				return null;
			IRegexpFilter filter = new RegexpFilterDescriptor<object>();
			foreach (var jv in j)
			{
				switch (jv.Key)
				{
					case "_cache":
						filter.Cache = jv.Value.Value<bool>();
						break;
					case "_cache_key":
						filter.CacheKey = jv.Value.Value<string>();
						break;
					case "_name":
						filter.FilterName = jv.Value.Value<string>();
						break;
					default:
						filter.Field = jv.Key;
						var value = jv.Value["value"];
						if (value != null)
							filter.Value = value.Value<string>();
						var flags = jv.Value["flags"];
						if (flags != null)
							filter.Flags = flags.Value<string>();
						break;
				}
			}

			return filter;

		}
		public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
		{
			var s = reader.Value as string;
		    if(s != null)
			{
				if (objectType == typeof(DateTime) || objectType == typeof(DateTime?))
				{
					DateTime time;
					if (DateTime.TryParseExact(s, Default.DateTimeFormatsToRead, CultureInfo.InvariantCulture,
					                           DateTimeStyles.RoundtripKind, out time))
					{
						if (time.Kind == DateTimeKind.Unspecified)
							return DateTime.SpecifyKind(time, DateTimeKind.Local);
						return time;
					}
				}
				if(objectType == typeof(DateTimeOffset) || objectType == typeof(DateTimeOffset?))
				{
					DateTimeOffset time;
					if (DateTimeOffset.TryParseExact(s, Default.DateTimeFormatsToRead, CultureInfo.InvariantCulture,
											   DateTimeStyles.RoundtripKind, out time))
						return time;
				}

			}
			return DeferReadToNextConverter(reader, objectType, serializer, existingValue);
		}
示例#30
0
 public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
 {
     var obj = JToken.ReadFrom(reader);
     var ret = JsonConvert.DeserializeObject(obj.ToString(), ObjectType ?? objectType, new JsonConverter[] { });
     if (obj["_embedded"] != null && obj["_embedded"].HasValues) {
         var enumerator = ((JObject) obj["_embedded"]).GetEnumerator();
         while (enumerator.MoveNext()) {
             var rel = enumerator.Current.Key;
             foreach (var property in objectType.GetProperties()) {
                 var attribute = property.GetCustomAttributes(true).FirstOrDefault(attr => attr is HalEmbeddedAttribute &&
                                                                                                                                                                     ((HalEmbeddedAttribute) attr).Rel == rel);
                 if (attribute != null) {
                     var type = (attribute as HalEmbeddedAttribute).Type ?? property.PropertyType;
                     property.SetValue(ret,
                                                         JsonConvert.DeserializeObject(enumerator.Current.Value.ToString(), type,
                                                                                                                     new JsonConverter[] {new HalResourceConverter((attribute as HalEmbeddedAttribute).CollectionMemberType)}), null);
                 }
             }
         }
     }
     if (obj["_links"] != null && obj["_links"].HasValues && typeof (IHalResource).IsAssignableFrom(objectType)) {
         ((HalResource) ret).Links = JsonConvert.DeserializeObject<HalLinkCollection>(obj["_links"].ToString(),
                                                                                      new JsonConverter[]
                                                                                      	{new HalLinkCollectionConverter()});
     }
     if (ret is IHalResource)
         ((IHalResource) ret).IsNew = false;
     return ret;
 }
示例#31
0
        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);
        }
示例#32
0
        public override ObjectId ReadJson(
            JsonReader reader,
            Type objectType,
            ObjectId existingValue,
            bool hasExistingValue,
            JsonSerializer serializer)
        {
            if (reader.TokenType != JsonToken.String)
            {
                var jsonLineInfo = (IJsonLineInfo)reader;
                throw new JsonSerializationException(
                          $"Unexpected token parsing ObjectId. Expected String, got {reader.TokenType}.",
                          reader.Path,
                          jsonLineInfo.LineNumber,
                          jsonLineInfo.LinePosition,
                          null);
            }

            var sval = reader.Value?.ToString();

            return(string.IsNullOrEmpty(sval) ? null : new ObjectId(sval));
        }
示例#33
0
 public override object ReadJson(NewtonsoftJson.JsonReader reader, Type objectType, object existingValue, NewtonsoftJson.JsonSerializer serializer)
 {
     if (TYPE_INT64 == reader.ValueType)
     {
         if (objectType == TYPE_DATETIME || objectType == TYPE_NULLABLE_DATETIME)
         {
             return(DateTimeExtensions.TIMESTAMP_BASE.AddSeconds((long)reader.Value));
         }
         else
         {
             return(reader.Value);
         }
     }
     else if (TYPE_DATETIME == reader.ValueType || TYPE_NULLABLE_DATETIME == reader.ValueType)
     {
         return(reader.Value);
     }
     else
     {
         return(null);
     }
 }
示例#34
0
        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);
        }
示例#35
0
        public override object ReadJson(Newtonsoft.Json.JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            object instance;

            if (reader.TokenType == JsonToken.Null)
            {
                return(null);
            }
            if (reader.TokenType == JsonToken.String)
            {
                return(new StackLayoutItem {
                    Control = Convert.ToString(reader.Value)
                });
            }

            var container = JObject.Load(reader);

            if (container["$type"] == null)
            {
                instance = new StackLayoutItem();
                serializer.Populate(container.CreateReader(), instance);
            }
            else
            {
                var type = Type.GetType((string)container["$type"]);
                if (!typeof(StackLayoutItem).IsAssignableFrom(type))
                {
                    var item = new StackLayoutItem();
                    item.Control = serializer.Deserialize(container.CreateReader()) as Control;
                    instance     = item;
                }
                else
                {
                    instance = serializer.Deserialize(container.CreateReader());
                }
            }
            return(instance);
        }
        /// <summary>
        /// Reads the JSON representation of the object.
        /// </summary>
        /// <param name="reader">The <see cref="JsonReader"/> to read from.</param>
        /// <param name="objectType">Type of the object.</param>
        /// <param name="existingValue">Existing Value</param>
        /// <param name="serializer">Serializer</param>
        /// <returns>The object value.</returns>
        public override object ReadJson(Newtonsoft.Json.JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            if (reader.TokenType == JsonToken.Null && objectType.IsAssignableFrom(typeof(DateTime?)))
            {
                return(null);
            }

            if (reader.TokenType == JsonToken.Date)
            {
                return((DateTime)reader.Value);
            }

            if (reader.TokenType != JsonToken.String)
            {
                throw new Exception("Unexpected token parsing date. Expected String, got {0}.".FormatWith(reader.TokenType));
            }

            if (reader.Value.ToString().IsEmpty())
            {
                return(null);
            }

            return(DateTime.Parse(reader.Value.ToString(), CultureInfo.InvariantCulture));
        }
            public override object ReadJson(Newtonsoft.Json.JsonReader reader, Type objectType, object existingValue,
                                            Newtonsoft.Json.JsonSerializer serializer)
            {
                JObject obj = serializer.Deserialize <JToken>(reader) as JObject;

                if (obj != null)
                {
                    string result       = obj["isSingleUnit"].ToObject <string>();
                    bool   isSingleUnit = ConvertToBool(result);
                    string name         = obj["name"].ToObject <string>();
                    if (isSingleUnit)
                    {
                        return(new NewtonTest.House(name, isSingleUnit));
                    }
                    else
                    {
                        return(new NewtonTest.Apartment(name, isSingleUnit));
                    }
                }
                else
                {
                    return(null);
                }
            }
        public override object ReadJson(Newtonsoft.Json.JsonReader reader, System.Type objectType, object existingValue, Newtonsoft.Json.JsonSerializer serializer)
        {
            JObject jObject = null;

            jObject = serializer.Deserialize <Newtonsoft.Json.Linq.JObject>(reader);

            if (jObject == null)
            {
                return(null);
            }

            var discriminator = Newtonsoft.Json.Linq.Extensions.Value <string>(jObject.GetValue(_discriminator));
            var subtype       = GetObjectSubtypeBetter(jObject, objectType, discriminator);

            try
            {
                _isReading = true;
                return(serializer.Deserialize(jObject.CreateReader(), subtype));
            }
            finally
            {
                _isReading = false;
            }
        }
示例#39
0
 public override object ReadJson(Newtonsoft.Json.JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
 {
     //If you need to deserialize, fill in the code here
     return(null);
 }
示例#40
0
        private void tvPdfDoc_NodeMouseClick(object sender, TreeNodeMouseClickEventArgs e)
        {
            if (e.Node.Tag == null || key_ == 0)
            {
                return;
            }

            txtStream.Text = string.Empty;
            var idxObj = e.Node.Tag as ObjInfo;
            var idx    = -1;

            if (idxObj != null && idxObj.idx_ >= 0)
            {
                idx = idxObj.idx_;
            }
            else if (chkRefResolve.Checked && idxObj.pdfObj_ != null && idxObj.pdfObj_.ContainsKey("$Type") && idxObj.refresolve_ == false)
            {
                // resolve obj ref;
                var objnum = Convert.ToInt32(idxObj.pdfObj_["num"]);
                idxObj.idx_ = objnum;
                var len  = PdfAnal.analObject(key_, objnum);
                var buff = new byte[len];                 //new StringBuilder((int)len);
                PdfAnal.getBuff(key_, buff);

                var docstr = Encoding.UTF8.GetString(buff);

                var jsr    = new Newtonsoft.Json.JsonReader(new StringReader(docstr));
                var js     = new Newtonsoft.Json.JsonSerializer();
                var jsroot = js.Deserialize(jsr);

                e.Node.Nodes.Clear();
                jsoFunc(jsroot, "", null, e.Node, false, 10);                   // 10は適当

                e.Node.Text = string.Format("{0} ({1} 0 R)", e.Node.Text, objnum);
            }
            else
            {
                return;
            }
            var stmlen = PdfAnal.analObjStream(key_, idx);

            if (stmlen == 0)
            {
                return;
            }
            var stmbuf = new byte[stmlen];

            PdfAnal.getBuff(key_, stmbuf);
            var tmpPath = Path.Combine(Path.GetTempPath(), "pdfanl.tmp");

            using (var tmp = new FileStream(tmpPath, FileMode.Create, FileAccess.Write)) {
                tmp.Write(stmbuf, 0, stmbuf.Length);
            }
            using (var tmp = new StreamReader(tmpPath)) {
                var txtBuf = new StringBuilder();
                while (true)
                {
                    var line = tmp.ReadLine();
                    if (line == null || txtBuf.Length > (2 << 15))
                    {
                        break;
                    }
                    txtBuf.AppendLine(line);
                }
                txtStream.Text = txtBuf.ToString();
            }
        }
        /// <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(Newtonsoft.Json.JsonReader reader, System.Type objectType, object existingValue, Newtonsoft.Json.JsonSerializer serializer)
        {
            JObject jObject = JObject.Load(reader);

            DataTable table = new DataTable();

            if (jObject["TableName"] != null)
            {
                table.TableName = jObject["TableName"].ToString();
            }

            if (jObject["Columns"] == null)
            {
                return(table);
            }

            // Loop through the columns in the table and apply any properties provided
            foreach (JObject jColumn in jObject["Columns"])
            {
                DataColumn column = new DataColumn();
                JToken     token  = default(JToken);

                token = jColumn.SelectToken("AllowDBNull");
                if (token != null)
                {
                    column.AllowDBNull = token.Value <bool>();
                }

                token = jColumn.SelectToken("AutoIncrement");
                if (token != null)
                {
                    column.AutoIncrement = token.Value <bool>();
                }

                token = jColumn.SelectToken("AutoIncrementSeed");
                if (token != null)
                {
                    column.AutoIncrementSeed = token.Value <long>();
                }

                token = jColumn.SelectToken("AutoIncrementStep");
                if (token != null)
                {
                    column.AutoIncrementStep = token.Value <long>();
                }

                token = jColumn.SelectToken("Caption");
                if (token != null)
                {
                    column.Caption = token.Value <string>();
                }

                token = jColumn.SelectToken("ColumnName");
                if (token != null)
                {
                    column.ColumnName = token.Value <string>();
                }

                // Allowed data types: http://msdn.microsoft.com/en-us/library/system.data.datacolumn.datatype.aspx
                token = jColumn.SelectToken("DataType");
                if (token != null)
                {
                    string dataType = token.Value <string>();
                    if (dataType == "Byte[]")
                    {
                        column.DataType = typeof(System.Byte[]);
                    }
                    else
                    {
                        // All allowed data types exist in the System namespace
                        column.DataType = Type.GetType(string.Concat("System.", dataType));
                    }
                }

                token = jColumn.SelectToken("DateTimeMode");
                if (token != null)
                {
                    column.DateTimeMode = (System.Data.DataSetDateTime)Enum.Parse(typeof(System.Data.DataSetDateTime), token.Value <string>());
                }

                // Can't set default value on auto increment column
                if (!column.AutoIncrement)
                {
                    token = jColumn.SelectToken("DefaultValue");
                    if (token != null)
                    {
                        column.DefaultValue = this.ConvertFromString(column.DataType, token.ToString());
                    }
                }

                token = jColumn.SelectToken("MaxLength");
                if (token != null)
                {
                    column.MaxLength = token.Value <int>();
                }

                token = jColumn.SelectToken("ReadOnly");
                if (token != null)
                {
                    column.ReadOnly = token.Value <bool>();
                }

                token = jColumn.SelectToken("Unique");
                if (token != null)
                {
                    column.Unique = token.Value <bool>();
                }

                table.Columns.Add(column);
            }

            // Add the rows to the table
            if (jObject["Rows"] != null)
            {
                foreach (JArray jRow in jObject["Rows"])
                {
                    DataRow row = table.NewRow();
                    // Each row is just an array of objects
                    row.ItemArray = jRow.ToObject <System.Object[]>();
                    table.Rows.Add(row);
                }
            }

            // Add the primary key to the table if supplied
            if (jObject["PrimaryKey"] != null)
            {
                List <DataColumn> primaryKey = new List <DataColumn>();
                foreach (JValue jPrimaryKey in jObject["PrimaryKey"])
                {
                    DataColumn column = table.Columns[jPrimaryKey.ToString()];
                    if (column == null)
                    {
                        throw new ApplicationException("Invalid primary key.");
                    }
                    else
                    {
                        primaryKey.Add(column);
                    }
                }
                table.PrimaryKey = primaryKey.ToArray();
            }

            return(table);
        }
示例#42
0
        public override object ReadJson(Newtonsoft.Json.JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            object     instance;
            JContainer container;

            if (reader.TokenType == JsonToken.Null)
            {
                return(null);
            }
            if (reader.TokenType == JsonToken.StartArray)
            {
                container = JArray.Load(reader);
                if (objectType == typeof(DynamicRow))
                {
                    var dynamicRow = new DynamicRow();
                    instance = dynamicRow;
                    serializer.Populate(container.CreateReader(), dynamicRow.Items);
                }
                else if (objectType == typeof(DynamicItem))
                {
                    var dynamicTable = new DynamicTable();
                    instance = dynamicTable;
                    serializer.Populate(container.CreateReader(), dynamicTable.Rows);
                }
                else
                {
                    throw new EtoException("Invalid object graph");
                }
            }
            else
            {
                container = JObject.Load(reader);
                if (container["$type"] == null)
                {
                    if (container["Rows"] != null)
                    {
                        instance = new DynamicTable();
                    }
                    else if (container["Control"] != null)
                    {
                        instance = new DynamicControl();
                    }
                    else
                    {
                        throw new EtoException("Could not infer the type of object to create");
                    }

                    serializer.Populate(container.CreateReader(), instance);
                }
                else
                {
                    var type = Type.GetType((string)container ["$type"]);
                    if (!typeof(DynamicItem).IsAssignableFrom(type))
                    {
                        var dynamicControl = new DynamicControl();
                        dynamicControl.Control = serializer.Deserialize(container.CreateReader()) as Control;
                        instance = dynamicControl;
                    }
                    else
                    {
                        instance = serializer.Deserialize(container.CreateReader());
                    }
                }
            }
            if (objectType == typeof(DynamicRow) && instance.GetType() != typeof(DynamicRow))
            {
                var row = new DynamicRow();
                row.Items.Add(instance as DynamicItem);
                return(row);
            }

            return(instance);
        }
示例#43
0
 public override object ReadJson(Newtonsoft.Json.JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
 {
     return(Enum.Parse(objectType, reader.Value.ToString(), true));
 }
示例#44
0
        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
        }
示例#45
0
            public override object ReadJson(Newtonsoft.Json.JsonReader reader, Type objectType, object existingValue, Newtonsoft.Json.JsonSerializer serializer)
            {
                var jToken = serializer.Deserialize <JToken>(reader);

                return(ConvertJToken(jToken, keepPrimitiveValues: false));
            }
示例#46
0
        /// <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(Newtonsoft.Json.JsonReader reader, System.Type objectType, object existingValue, Newtonsoft.Json.JsonSerializer serializer)
        {
            JObject jObject = JObject.Load(reader);

            DataTable table = new DataTable();

            if (jObject["TableName"] != null)
            {
                table.TableName = jObject["TableName"].ToString();
            }

            if (jObject["Columns"] == null)
            {
                return(table);
            }

            // Loop through the columns in the table and apply any properties provided
            foreach (JObject jColumn in jObject["Columns"])
            {
                DataColumn column = new DataColumn();
                JToken     token  = default(JToken);

                token = jColumn.SelectToken("AllowDBNull");
                if (token != null)
                {
                    column.AllowDBNull = token.Value <bool>();
                }

                token = jColumn.SelectToken("AutoIncrement");
                if (token != null)
                {
                    column.AutoIncrement = token.Value <bool>();
                }

                token = jColumn.SelectToken("AutoIncrementSeed");
                if (token != null)
                {
                    column.AutoIncrementSeed = token.Value <long>();
                }

                token = jColumn.SelectToken("AutoIncrementStep");
                if (token != null)
                {
                    column.AutoIncrementStep = token.Value <long>();
                }

                token = jColumn.SelectToken("Caption");
                if (token != null)
                {
                    column.Caption = token.Value <string>();
                }

                token = jColumn.SelectToken("ColumnName");
                if (token != null)
                {
                    column.ColumnName = token.Value <string>();
                }

                // Allowed data types: http://msdn.microsoft.com/en-us/library/system.data.datacolumn.datatype.aspx
                token = jColumn.SelectToken("DataType");
                if (token != null)
                {
                    string dataType = token.Value <string>();
                    if (dataType == "Byte[]")
                    {
                        column.DataType = typeof(System.Byte[]);
                    }
                    else
                    {
                        // All allowed data types exist in the System namespace
                        column.DataType = Type.GetType(string.Concat("System.", dataType));
                    }
                }

                token = jColumn.SelectToken("DateTimeMode");
                if (token != null)
                {
                    column.DateTimeMode = (DataSetDateTime)Enum.Parse(typeof(System.Data.DataSetDateTime), token.Value <string>());
                }

                // Can't set default value on auto increment column
                if (!column.AutoIncrement)
                {
                    token = jColumn.SelectToken("DefaultValue");
                    if (token != null)
                    {
                        // If a default value is provided then cast to the columns data type
                        switch (column.DataType.Name)
                        {
                        case "Boolean":
                            bool defaultValueBool = false;
                            if (bool.TryParse(token.ToString(), out defaultValueBool))
                            {
                                column.DefaultValue = defaultValueBool;
                            }
                            break;

                        case "Byte":
                            byte defaultValueByte = 0;
                            if (byte.TryParse(token.ToString(), out defaultValueByte))
                            {
                                column.DefaultValue = defaultValueByte;
                            }
                            break;

                        case "Char":
                            char defaultValueChar = '\0';
                            if (char.TryParse(token.ToString(), out defaultValueChar))
                            {
                                column.DefaultValue = defaultValueChar;
                            }
                            break;

                        case "DateTime":
                            DateTime defaultValueDateTime = default(DateTime);
                            if (DateTime.TryParse(token.ToString(), out defaultValueDateTime))
                            {
                                column.DefaultValue = defaultValueDateTime;
                            }
                            break;

                        case "Decimal":
                            decimal defaultValueDeciumal = default(decimal);
                            if (decimal.TryParse(token.ToString(), out defaultValueDeciumal))
                            {
                                column.DefaultValue = defaultValueDeciumal;
                            }
                            break;

                        case "Double":
                            double defaultValueDouble = 0;
                            if (double.TryParse(token.ToString(), out defaultValueDouble))
                            {
                                column.DefaultValue = defaultValueDouble;
                            }
                            break;

                        case "Guid":
                            Guid defaultValueGuid = default(Guid);
                            if (Guid.TryParse(token.ToString(), out defaultValueGuid))
                            {
                                column.DefaultValue = defaultValueGuid;
                            }
                            break;

                        case "Int16":
                            Int16 defaultValueInt16 = default(Int16);
                            if (Int16.TryParse(token.ToString(), out defaultValueInt16))
                            {
                                column.DefaultValue = defaultValueInt16;
                            }
                            break;

                        case "Int32":
                            Int32 defaultValueInt32 = default(Int32);
                            if (Int32.TryParse(token.ToString(), out defaultValueInt32))
                            {
                                column.DefaultValue = defaultValueInt32;
                            }
                            break;

                        case "Int64":
                            Int64 defaultValueInt64 = default(Int64);
                            if (Int64.TryParse(token.ToString(), out defaultValueInt64))
                            {
                                column.DefaultValue = defaultValueInt64;
                            }
                            break;

                        case "SByte":
                            sbyte defaultValueSByte = 0;
                            if (sbyte.TryParse(token.ToString(), out defaultValueSByte))
                            {
                                column.DefaultValue = defaultValueSByte;
                            }
                            break;

                        case "Single":
                            float defaultValueSingle = 0;
                            if (float.TryParse(token.ToString(), out defaultValueSingle))
                            {
                                column.DefaultValue = defaultValueSingle;
                            }
                            break;

                        case "String":
                            column.DefaultValue = token.ToString();
                            break;

                        case "TimeSpan":
                            TimeSpan defaultValueTimeSpan = default(TimeSpan);
                            if (TimeSpan.TryParse(token.ToString(), out defaultValueTimeSpan))
                            {
                                column.DefaultValue = defaultValueTimeSpan;
                            }
                            break;

                        case "UInt16":
                            UInt16 defaultValueUInt16 = default(UInt16);
                            if (UInt16.TryParse(token.ToString(), out defaultValueUInt16))
                            {
                                column.DefaultValue = defaultValueUInt16;
                            }
                            break;

                        case "UInt32":
                            UInt32 defaultValueUInt32 = default(UInt32);
                            if (UInt32.TryParse(token.ToString(), out defaultValueUInt32))
                            {
                                column.DefaultValue = defaultValueUInt32;
                            }
                            break;

                        case "UInt64":
                            UInt64 defaultValueUInt64 = default(UInt64);
                            if (UInt64.TryParse(token.ToString(), out defaultValueUInt64))
                            {
                                column.DefaultValue = defaultValueUInt64;
                            }
                            break;

                        case "Byte[]":
                            break;
                            // Leave as null
                        }
                    }
                }

                token = jColumn.SelectToken("MaxLength");
                if (token != null)
                {
                    column.MaxLength = token.Value <int>();
                }

                token = jColumn.SelectToken("ReadOnly");
                if (token != null)
                {
                    column.ReadOnly = token.Value <bool>();
                }

                token = jColumn.SelectToken("Unique");
                if (token != null)
                {
                    column.Unique = token.Value <bool>();
                }

                table.Columns.Add(column);
            }

            // Add the rows to the table
            if (jObject["Rows"] != null)
            {
                foreach (JArray jRow in jObject["Rows"])
                {
                    DataRow row = table.NewRow();
                    // Each row is just an array of objects
                    row.ItemArray = jRow.ToObject <System.Object[]>();
                    table.Rows.Add(row);
                }
            }

            // Add the primary key to the table if supplied
            if (jObject["PrimaryKey"] != null)
            {
                List <DataColumn> primaryKey = new List <DataColumn>();
                foreach (JValue jPrimaryKey in jObject["PrimaryKey"])
                {
                    DataColumn column = table.Columns[jPrimaryKey.ToString()];
                    if (column == null)
                    {
                        throw new ApplicationException("Invalid primary key.");
                    }
                    else
                    {
                        primaryKey.Add(column);
                    }
                }
                table.PrimaryKey = primaryKey.ToArray();
            }

            return(table);
        }
示例#47
0
 public override object ReadJson(Newtonsoft.Json.JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
 {
     return(PaperSize.GetPaperSize(reader.Value as string));
 }
示例#48
0
 public override object ReadJson(Newtonsoft.Json.JsonReader reader, Type objectType, object existingValue, Newtonsoft.Json.JsonSerializer serializer)
 {
     return(DateTime.Parse(reader.Value.ToString()));
 }
 public static JsonNewtonsoftReader Create(Newtonsoft.Json.JsonReader reader)
 {
     return(new JsonNewtonsoftReader(reader));
 }
示例#50
0
        public override object ReadJson(Newtonsoft.Json.JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            object     instance;
            JContainer container;

            if (reader.TokenType == JsonToken.Null)
            {
                return(null);
            }
            if (reader.TokenType == JsonToken.String)
            {
                if (objectType == typeof(TableRow))
                {
                    return(new TableRow(Convert.ToString(reader.Value)));
                }
                if (objectType == typeof(TableCell))
                {
                    return(new TableCell(Convert.ToString(reader.Value)));
                }
            }
            if (reader.TokenType == JsonToken.StartArray)
            {
                container = JArray.Load(reader);
                if (objectType == typeof(TableRow))
                {
                    var row = new TableRow();
                    instance = row;
                    serializer.Populate(container.CreateReader(), row.Cells);
                }
                else if (objectType == typeof(TableCell))
                {
                    var table = new TableLayout();
                    serializer.Populate(container.CreateReader(), table.Rows);
                    instance = new TableCell(table);
                }
                else
                {
                    throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, "Invalid object graph"));
                }
            }
            else
            {
                container = JObject.Load(reader);
                if (container["$type"] == null)
                {
                    if (container["Rows"] != null)
                    {
                        instance = new TableLayout();
                    }
                    else if (container["Cells"] != null)
                    {
                        instance = new TableRow();
                    }
                    else if (container["Control"] != null)
                    {
                        instance = new TableCell();
                    }
                    else if (objectType == typeof(TableRow))
                    {
                        instance = new TableRow();
                    }
                    else if (objectType == typeof(TableCell))
                    {
                        instance = new TableCell();
                    }
                    else
                    {
                        throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, "Could not infer the type of object to create"));
                    }

                    serializer.Populate(container.CreateReader(), instance);
                }
                else
                {
                    var type = Type.GetType((string)container["$type"]);
                    if (!typeof(TableCell).IsAssignableFrom(type))
                    {
                        var cell = new TableCell();
                        cell.Control = serializer.Deserialize(container.CreateReader()) as Control;
                        instance     = cell;
                    }
                    else
                    {
                        instance = serializer.Deserialize(container.CreateReader());
                    }
                }
            }
            if (objectType == typeof(TableRow) && !(instance is TableRow))
            {
                var row  = new TableRow();
                var cell = instance as TableCell;
                if (cell == null)
                {
                    cell = new TableCell(instance as Control);
                }
                row.Cells.Add(cell);
                return(row);
            }

            return(instance);
        }
示例#51
0
 public override object ReadJson(Newtonsoft.Json.JsonReader reader, Type objectType, object existingValue, Newtonsoft.Json.JsonSerializer serializer)
 {
     return(DateTime.ParseExact((string)reader.Value, "MM/yyyy", CultureInfo.InvariantCulture));
 }
示例#52
0
    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        var data = reader.ReadAsString();

        return(data.ToColor());
    }
示例#53
0
        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();
                }
            }
        }
示例#54
0
 /// <inheritdoc/>
 public override object ReadJson(Newtonsoft.Json.JsonReader reader, Type objectType, object existingValue,
                                 JsonSerializer serializer)
 {
     throw new NotImplementedException("Unnecessary because CanRead is false.");
 }
示例#55
0
        /// <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(Newtonsoft.Json.JsonReader reader, System.Type objectType, object existingValue, Newtonsoft.Json.JsonSerializer serializer)
        {
            JObject jObject = JObject.Load(reader);

            DataTable table = new DataTable();

            if (jObject["TableName"] != null)
            {
                table.TableName = jObject["TableName"].ToString();
            }

            if (jObject["Columns"] == null)
            {
                return(table);
            }

            // Loop through the columns in the table and apply any properties provided
            foreach (JObject jColumn in jObject["Columns"])
            {
                DataColumn column = new DataColumn();
                JToken     token  = default(JToken);

                token = jColumn.SelectToken("AllowDBNull");
                if (token != null)
                {
                    column.AllowDBNull = token.Value <bool>();
                }

                token = jColumn.SelectToken("AutoIncrement");
                if (token != null)
                {
                    column.AutoIncrement = token.Value <bool>();
                }

                token = jColumn.SelectToken("AutoIncrementSeed");
                if (token != null)
                {
                    column.AutoIncrementSeed = token.Value <long>();
                }

                token = jColumn.SelectToken("AutoIncrementStep");
                if (token != null)
                {
                    column.AutoIncrementStep = token.Value <long>();
                }

                token = jColumn.SelectToken("Caption");
                if (token != null)
                {
                    column.Caption = token.Value <string>();
                }

                token = jColumn.SelectToken("ColumnName");
                if (token != null)
                {
                    column.ColumnName = token.Value <string>();
                }

                // Allowed data types: http://msdn.microsoft.com/en-us/library/system.data.datacolumn.datatype.aspx
                token = jColumn.SelectToken("DataType");
                if (token != null)
                {
                    string dataType = token.Value <string>();
                    if (dataType == "Byte[]")
                    {
                        column.DataType = typeof(System.Byte[]);
                    }
                    else
                    {
                        // All allowed data types exist in the System namespace
                        column.DataType = System.Type.GetType(string.Concat("System.", dataType));
                    }
                }

                token = jColumn.SelectToken("DateTimeMode");
                if (token != null)
                {
                    DataSetDateTime dtm;
                    Enum.TryParse <DataSetDateTime>(token.Value <string>(), out dtm);
                    column.DateTimeMode = dtm;
                }

                // Can't set default value on auto increment column
                if (!column.AutoIncrement)
                {
                    token = jColumn.SelectToken("DefaultValue");
                    if (token != null)
                    {
                        // If a default value is provided then cast to the columns data type
                        if (column.DataType == typeof(System.Boolean))
                        {
                            bool defaultValue = false;
                            if (bool.TryParse(token.ToString(), out defaultValue))
                            {
                                column.DefaultValue = defaultValue;
                            }
                        }
                        else
                        {
                            if (column.DataType == typeof(System.Byte))
                            {
                                byte defaultValue = 0;
                                if (byte.TryParse(token.ToString(), out defaultValue))
                                {
                                    column.DefaultValue = defaultValue;
                                }
                            }
                            else
                            {
                                /*
                                 * case typeof(System.Char):
                                 * char defaultValue = '\0';
                                 * if (char.TryParse(token.ToString(), out defaultValue))
                                 * {
                                 *  column.DefaultValue = defaultValue;
                                 * }
                                 * break;
                                 * case typeof(System.DateTime):
                                 * DateTime defaultValue = default(DateTime);
                                 * if (DateTime.TryParse(token.ToString(), out defaultValue))
                                 * {
                                 *  column.DefaultValue = defaultValue;
                                 * }
                                 * break;
                                 * case typeof(System.Decimal):
                                 * decimal defaultValue = default(decimal);
                                 * if (decimal.TryParse(token.ToString(), out defaultValue))
                                 * {
                                 *  column.DefaultValue = defaultValue;
                                 * }
                                 * break;
                                 * case typeof(System.Double):
                                 * double defaultValue = 0;
                                 * if (double.TryParse(token.ToString(), out defaultValue))
                                 * {
                                 *  column.DefaultValue = defaultValue;
                                 * }
                                 * break;
                                 * case typeof(System.Guid):
                                 * Guid defaultValue = default(Guid);
                                 * if (Guid.TryParse(token.ToString(), out defaultValue))
                                 * {
                                 *  column.DefaultValue = defaultValue;
                                 * }
                                 * break;
                                 * case typeof(System.Int16):
                                 * Int16 defaultValue = default(Int16);
                                 * if (Int16.TryParse(token.ToString(), out defaultValue))
                                 * {
                                 *  column.DefaultValue = defaultValue;
                                 * }
                                 * break;
                                 * case typeof(System.Int32):
                                 * Int32 defaultValue = default(Int32);
                                 * if (Int32.TryParse(token.ToString(), out defaultValue))
                                 * {
                                 *  column.DefaultValue = defaultValue;
                                 * }
                                 * break;
                                 * case typeof(System.Int64):
                                 * Int64 defaultValue = default(Int64);
                                 * if (Int64.TryParse(token.ToString(), out defaultValue))
                                 * {
                                 *  column.DefaultValue = defaultValue;
                                 * }
                                 * break;
                                 * case typeof(System.SByte):
                                 * sbyte defaultValue = 0;
                                 * if (sbyte.TryParse(token.ToString(), out defaultValue))
                                 * {
                                 *  column.DefaultValue = defaultValue;
                                 * }
                                 * break;
                                 * case typeof(System.Single):
                                 * float defaultValue = 0;
                                 * if (float.TryParse(token.ToString(), out defaultValue))
                                 * {
                                 *  column.DefaultValue = defaultValue;
                                 * }
                                 * break;
                                 * case typeof(System.String):
                                 * column.DefaultValue = token.ToString();
                                 * break;
                                 * case typeof(System.TimeSpan):
                                 * TimeSpan defaultValue = default(TimeSpan);
                                 * if (TimeSpan.TryParse(token.ToString(), out defaultValue))
                                 * {
                                 *  column.DefaultValue = defaultValue;
                                 * }
                                 * break;
                                 * case typeof(System.UInt16):
                                 * UInt16 defaultValue = default(UInt16);
                                 * if (UInt16.TryParse(token.ToString(), out defaultValue))
                                 * {
                                 *  column.DefaultValue = defaultValue;
                                 * }
                                 * break;
                                 * case typeof(System.UInt32):
                                 * UInt32 defaultValue = default(UInt32);
                                 * if (UInt32.TryParse(token.ToString(), out defaultValue))
                                 * {
                                 *  column.DefaultValue = defaultValue;
                                 * }
                                 * break;
                                 * case typeof(System.UInt64):
                                 * UInt64 defaultValue = default(UInt64);
                                 * if (UInt64.TryParse(token.ToString(), out defaultValue))
                                 * {
                                 *  column.DefaultValue = defaultValue;
                                 * }
                                 * break;
                                 * case typeof(System.Byte[]):
                                 * break;
                                 * // Leave as null
                                 */
                            }
                        }
                    }
                }

                token = jColumn.SelectToken("MaxLength");
                if (token != null)
                {
                    column.MaxLength = token.Value <int>();
                }

                token = jColumn.SelectToken("ReadOnly");
                if (token != null)
                {
                    column.ReadOnly = token.Value <bool>();
                }

                token = jColumn.SelectToken("Unique");
                if (token != null)
                {
                    column.Unique = token.Value <bool>();
                }

                table.Columns.Add(column);
            }

            // Add the rows to the table
            if (jObject["Rows"] != null)
            {
                foreach (JArray jRow in jObject["Rows"])
                {
                    DataRow row = table.NewRow();
                    // Each row is just an array of objects
                    row.ItemArray = jRow.ToObject <System.Object[]>();
                    table.Rows.Add(row);
                }
            }

            // Add the primary key to the table if supplied
            if (jObject["PrimaryKey"] != null)
            {
                List <DataColumn> primaryKey = new List <DataColumn>();
                foreach (JValue jPrimaryKey in jObject["PrimaryKey"])
                {
                    DataColumn column = table.Columns[jPrimaryKey.ToString()];
                    if (column == null)
                    {
                        throw new ApplicationException("Invalid primary key.");
                    }
                    else
                    {
                        primaryKey.Add(column);
                    }
                }
                table.PrimaryKey = primaryKey.ToArray();
            }

            return(table);
        }
示例#56
0
 public override object ReadJson(Newtonsoft.Json.JsonReader reader, Type objectType, object existingValue, Newtonsoft.Json.JsonSerializer serializer)
 {
     return(serializer.Deserialize(reader, typeof(IDictionary <string, object>)));
 }
示例#57
0
        public override object ReadJson(Newtonsoft.Json.JsonReader reader, Type objectType,
                                        object existingValue, Newtonsoft.Json.JsonSerializer serializer)
        {
            if (reader.TokenType == Newtonsoft.Json.JsonToken.Null)
            {
                return(null);
            }

            try
            {
                var token = (JObject)JToken.Load(reader);

                var isCamelCased = true;
                WalkNode(token, null,
                         t =>
                {
                    var nameFirstChar = t.Name[0].ToString();
                    if (!nameFirstChar.Equals(nameFirstChar.ToLower(),
                                              StringComparison.CurrentCulture))
                    {
                        isCamelCased = false;
                        return;
                    }
                });

                if (!isCamelCased)
                {
                    return(null);
                }

                return(token.ToObject(objectType));
            }
            catch (System.Exception) {
            }

            try
            {
                var token = (JArray)JToken.Load(reader);

                var isCamelCased = true;
                WalkNode(token, null,
                         t =>
                {
                    var nameFirstChar = t.Name[0].ToString();
                    if (!nameFirstChar.Equals(nameFirstChar.ToLower(),
                                              StringComparison.CurrentCulture))
                    {
                        isCamelCased = false;
                        return;
                    }
                });
                if (!isCamelCased)
                {
                    return(null);
                }

                return(token.ToObject(objectType));
            }
            catch (System.Exception) { }

            return(null);
        }
示例#58
0
 public override object ReadJson(Newtonsoft.Json.JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
 {
     return(new ObjectId((string)reader.Value));
 }
示例#59
0
 public override object ReadJson(Newtonsoft.Json.JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
 {
     throw new NotImplementedException();
 }
示例#60
0
 public override object ReadJson(Newtonsoft.Json.JsonReader reader, Type objectType)
 {
     throw new NotImplementedException();
 }