private IList PopulateList(IList list, JsonReader reader, string reference, JsonArrayContract contract)
        {
            if (reference != null)
            {
                _serializer.ReferenceResolver.AddReference(reference, list);
            }

            contract.InvokeOnDeserializing(list);

            while (reader.Read())
            {
                switch (reader.TokenType)
                {
                case JsonToken.EndArray:
                    contract.InvokeOnDeserialized(list);

                    return(list);

                case JsonToken.Comment:
                    break;

                default:
                    object value = CreateValue(reader, contract.CollectionItemType, null, null);

                    list.Add(value);
                    break;
                }
            }

            throw new JsonSerializationException("Unexpected end when deserializing array.");
        }
Example #2
0
        private object PopulateList(IWrappedCollection wrappedList, JsonReader reader, string reference, JsonArrayContract contract)
        {
            object list = wrappedList.UnderlyingCollection;

            if (reference != null)
            {
                Serializer.ReferenceResolver.AddReference(reference, list);
            }

            contract.InvokeOnDeserializing(list, Serializer.Context);

            int initialDepth = reader.Depth;

            while (ReadForTypeArrayHack(reader, contract.CollectionItemType))
            {
                switch (reader.TokenType)
                {
                case JsonToken.EndArray:
                    contract.InvokeOnDeserialized(list, Serializer.Context);

                    return(wrappedList.UnderlyingCollection);

                case JsonToken.Comment:
                    break;

                default:
                    try
                    {
                        object value = CreateValueNonProperty(reader, contract.CollectionItemType, GetContractSafe(contract.CollectionItemType));

                        wrappedList.Add(value);
                    }
                    catch (Exception ex)
                    {
                        if (IsErrorHandled(list, contract, wrappedList.Count, ex))
                        {
                            HandleError(reader, initialDepth);
                        }
                        else
                        {
                            throw;
                        }
                    }
                    break;
                }
            }

            throw new JsonSerializationException("Unexpected end when deserializing array.");
        }
Example #3
0
        private object PopulateList(IWrappedCollection wrappedList, JsonReader reader, string reference, JsonArrayContract contract)
        {
            object underlyingCollection = wrappedList.UnderlyingCollection;

            if (wrappedList.IsFixedSize)
            {
                reader.Skip();
                return(wrappedList.UnderlyingCollection);
            }
            if (reference != null)
            {
                base.Serializer.ReferenceResolver.AddReference(this, reference, underlyingCollection);
            }
            contract.InvokeOnDeserializing(underlyingCollection, base.Serializer.Context);
            int depth = reader.Depth;

            while (ReadForTypeArrayHack(reader, contract.CollectionItemType))
            {
                switch (reader.TokenType)
                {
                case JsonToken.EndArray:
                    contract.InvokeOnDeserialized(underlyingCollection, base.Serializer.Context);
                    return(wrappedList.UnderlyingCollection);

                case JsonToken.Comment:
                    continue;
                }
                try
                {
                    object value = CreateValueNonProperty(reader, contract.CollectionItemType, GetContractSafe(contract.CollectionItemType));
                    wrappedList.Add(value);
                }
                catch (Exception ex)
                {
                    if (IsErrorHandled(underlyingCollection, contract, wrappedList.Count, ex))
                    {
                        HandleError(reader, depth);
                        continue;
                    }
                    throw;
                }
            }
            throw new JsonSerializationException("Unexpected end when deserializing array.");
        }
    private object PopulateList(IWrappedCollection wrappedList, JsonReader reader, string reference, JsonArrayContract contract)
    {
      object list = wrappedList.UnderlyingCollection;

      // can't populate an existing array
      if (wrappedList.IsFixedSize)
      {
        reader.Skip();
        return wrappedList.UnderlyingCollection;
      }

      if (reference != null)
        Serializer.ReferenceResolver.AddReference(this, reference, list);

      contract.InvokeOnDeserializing(list, Serializer.Context);

      int initialDepth = reader.Depth;
      int index = 0;

      JsonContract collectionItemContract = GetContractSafe(contract.CollectionItemType);
      JsonConverter collectionItemConverter = GetConverter(collectionItemContract, null);

      while (true)
      {
        try
        {
          if (ReadForType(reader, collectionItemContract, collectionItemConverter != null, true))
          {
            switch (reader.TokenType)
            {
              case JsonToken.EndArray:
                contract.InvokeOnDeserialized(list, Serializer.Context);

                return wrappedList.UnderlyingCollection;
              case JsonToken.Comment:
                break;
              default:
                object value = CreateValueNonProperty(reader, contract.CollectionItemType, collectionItemContract, collectionItemConverter);

                wrappedList.Add(value);
                break;
            }
          }
          else
          {
            break;
          }
        }
        catch (Exception ex)
        {
          if (IsErrorHandled(list, contract, index, reader.Path, ex))
            HandleError(reader, initialDepth);
          else
            throw;
        }
        finally
        {
          index++;
        }
      }

      throw CreateSerializationException(reader, "Unexpected end when deserializing array.");
    }
    private object PopulateList(IWrappedCollection wrappedList, JsonReader reader, string reference, JsonArrayContract contract)
    {
      object list = wrappedList.UnderlyingCollection;

      if (reference != null)
        Serializer.ReferenceResolver.AddReference(reference, list);

      contract.InvokeOnDeserializing(list, Serializer.Context);

      int initialDepth = reader.Depth;

      while (reader.Read())
      {
        switch (reader.TokenType)
        {
          case JsonToken.EndArray:
            contract.InvokeOnDeserialized(list, Serializer.Context);

            return wrappedList.UnderlyingCollection;
          case JsonToken.Comment:
            break;
          default:
            try
            {
              object value = CreateValueNonProperty(reader, contract.CollectionItemType, GetContractSafe(contract.CollectionItemType));

              wrappedList.Add(value);
            }
            catch (Exception ex)
            {
              if (IsErrorHandled(list, contract, wrappedList.Count, ex))
                HandleError(reader, initialDepth);
              else
                throw;
            }
            break;
        }
      }

      throw new JsonSerializationException("Unexpected end when deserializing array.");
    }
    private object PopulateList(IWrappedCollection wrappedList, JsonReader reader, JsonArrayContract contract, JsonProperty containerProperty, string id)
    {
      object list = wrappedList.UnderlyingCollection;

      if (id != null)
        Serializer.ReferenceResolver.AddReference(this, id, list);

      // can't populate an existing array
      if (wrappedList.IsFixedSize)
      {
        reader.Skip();
        return list;
      }

      contract.InvokeOnDeserializing(list, Serializer.Context);

      int initialDepth = reader.Depth;

      JsonContract collectionItemContract = GetContractSafe(contract.CollectionItemType);
      JsonConverter collectionItemConverter = GetConverter(collectionItemContract, null, contract, containerProperty);

      int? previousErrorIndex = null;

      while (true)
      {
        try
        {
          if (ReadForType(reader, collectionItemContract, collectionItemConverter != null))
          {
            switch (reader.TokenType)
            {
              case JsonToken.EndArray:
                contract.InvokeOnDeserialized(list, Serializer.Context);

                return list;
              case JsonToken.Comment:
                break;
              default:
                object value;

                if (collectionItemConverter != null && collectionItemConverter.CanRead)
                  value = collectionItemConverter.ReadJson(reader, contract.CollectionItemType, null, GetInternalSerializer());
                else
                  value = CreateValueInternal(reader, contract.CollectionItemType, collectionItemContract, null, contract, containerProperty, null);

                wrappedList.Add(value);
                break;
            }
          }
          else
          {
            break;
          }
        }
        catch (Exception ex)
        {
          JsonPosition errorPosition = reader.GetPosition(initialDepth);

          if (IsErrorHandled(list, contract, errorPosition.Position, reader.Path, ex))
          {
            HandleError(reader, true, initialDepth);

            if (previousErrorIndex != null && previousErrorIndex == errorPosition.Position)
            {
              // reader index has not moved since previous error handling
              // break out of reading array to prevent infinite loop
              throw JsonSerializationException.Create(reader, "Infinite loop detected from error handling.", ex);
            }
            else
            {
              previousErrorIndex = errorPosition.Position;
            }
          }
          else
          {
            throw;
          }
        }
      }

      throw JsonSerializationException.Create(reader, "Unexpected end when deserializing array.");
    }
    private object PopulateMultidimensionalArray(IList list, JsonReader reader, JsonArrayContract contract, JsonProperty containerProperty, string id)
    {
      int rank = contract.UnderlyingType.GetArrayRank();

      if (id != null)
        Serializer.ReferenceResolver.AddReference(this, id, list);

      contract.InvokeOnDeserializing(list, Serializer.Context);

      JsonContract collectionItemContract = GetContractSafe(contract.CollectionItemType);
      JsonConverter collectionItemConverter = GetConverter(collectionItemContract, null, contract, containerProperty);

      int? previousErrorIndex = null;
      Stack<IList> listStack = new Stack<IList>();
      listStack.Push(list);
      IList currentList = list;

      while (true)
      {
        int initialDepth = reader.Depth;

        if (listStack.Count == rank)
        {
          try
          {
            if (ReadForType(reader, collectionItemContract, collectionItemConverter != null))
            {
              switch (reader.TokenType)
              {
                case JsonToken.EndArray:
                  listStack.Pop();
                  currentList = listStack.Peek();
                  previousErrorIndex = null;
                  break;
                case JsonToken.Comment:
                  break;
                default:
                  object value;

                  if (collectionItemConverter != null && collectionItemConverter.CanRead)
                    value = collectionItemConverter.ReadJson(reader, contract.CollectionItemType, null, GetInternalSerializer());
                  else
                    value = CreateValueInternal(reader, contract.CollectionItemType, collectionItemContract, null, contract, containerProperty, null);

                  currentList.Add(value);
                  break;
              }
            }
            else
            {
              break;
            }
          }
          catch (Exception ex)
          {
            JsonPosition errorPosition = reader.GetPosition(initialDepth);

            if (IsErrorHandled(list, contract, errorPosition.Position, reader.Path, ex))
            {
              HandleError(reader, true, initialDepth);

              if (previousErrorIndex != null && previousErrorIndex == errorPosition.Position)
              {
                // reader index has not moved since previous error handling
                // break out of reading array to prevent infinite loop
                throw JsonSerializationException.Create(reader, "Infinite loop detected from error handling.", ex);
              }
              else
              {
                previousErrorIndex = errorPosition.Position;
              }
            }
            else
            {
              throw;
            }
          }
        }
        else
        {
          if (reader.Read())
          {
            switch (reader.TokenType)
            {
              case JsonToken.StartArray:
                IList newList = new List<object>();
                currentList.Add(newList);
                listStack.Push(newList);
                currentList = newList;
                break;
              case JsonToken.EndArray:
                listStack.Pop();

                if (listStack.Count > 0)
                {
                  currentList = listStack.Peek();
                }
                else
                {
                  contract.InvokeOnDeserialized(list, Serializer.Context);

                  return list;
                }
                break;
              case JsonToken.Comment:
                break;
              default:
                throw JsonSerializationException.Create(reader, "Unexpected token when deserializing multidimensional array: " + reader.TokenType);
            }
          }
          else
          {
            break;
          }
        }
      }

      throw JsonSerializationException.Create(reader, "Unexpected end when deserializing array.");
    }
		private object PopulateMultidimensionalArray(IList list, JsonReader reader, string reference, JsonArrayContract contract)
		{
			int rank = contract.UnderlyingType.GetArrayRank();

			if (reference != null)
				Serializer.ReferenceResolver.AddReference(this, reference, list);

			contract.InvokeOnDeserializing(list, Serializer.Context);

			//JsonContract collectionItemContract = GetContractSafe(contract.CollectionItemType);
			//JsonConverter collectionItemConverter = GetConverter(collectionItemContract, null, contract, containerProperty);

			//int? previousErrorIndex = null;
			Stack<IList> listStack = new Stack<IList>();
			listStack.Push(list);
			IList currentList = list;

			bool finished = false;
			do
			{
				int initialDepth = reader.Depth;

				if (listStack.Count == rank)
				{
					if (ReadForTypeArrayHack(reader, contract.CollectionItemType))
					{
						switch (reader.TokenType)
						{
							case JsonToken.EndArray:
								listStack.Pop();
								currentList = listStack.Peek();
								//previousErrorIndex = null;
								break;
							case JsonToken.Comment:
								break;
							default:
								try
								{
									object value = CreateValueNonProperty(reader, contract.CollectionItemType, GetContractSafe(contract.CollectionItemType));

									currentList.Add(value);
								}
								catch (Exception ex)
								{
									if (IsErrorHandled(list, contract, currentList.Count, ex))
										HandleError(reader, initialDepth);
									else
										throw;
								}
								break;
						}
					}
					else
					{
						break;
					}


				}
				else
				{
					if (reader.Read())
					{
						switch (reader.TokenType)
						{
							case JsonToken.StartArray:
								IList newList = new List<object>();
								currentList.Add(newList);
								listStack.Push(newList);
								currentList = newList;
								break;
							case JsonToken.EndArray:
								listStack.Pop();

								if (listStack.Count > 0)
								{
									currentList = listStack.Peek();
								}
								else
								{
									finished = true;
								}
								break;
							case JsonToken.Comment:
								break;
							default:
								throw new JsonSerializationException("Unexpected token when deserializing multidimensional array: " + reader.TokenType);
						}
					}
					else
					{
						break;
					}
				}
			} while (!finished);

			if (!finished)
				throw new JsonSerializationException("Unexpected end when deserializing array." + reader.TokenType);

			contract.InvokeOnDeserialized(list, Serializer.Context);
			return list;
		}
 private object PopulateList(IWrappedCollection wrappedList, JsonReader reader, JsonArrayContract contract, JsonProperty containerProperty, string id)
 {
   object underlyingCollection = wrappedList.UnderlyingCollection;
   if (id != null)
     this.AddReference(reader, id, underlyingCollection);
   if (wrappedList.IsFixedSize)
   {
     reader.Skip();
     return underlyingCollection;
   }
   else
   {
     contract.InvokeOnDeserializing(underlyingCollection, this.Serializer.Context);
     int depth = reader.Depth;
     JsonContract contractSafe = this.GetContractSafe(contract.CollectionItemType);
     JsonConverter converter = this.GetConverter(contractSafe, (JsonConverter) null, (JsonContainerContract) contract, containerProperty);
     int? nullable1 = new int?();
     bool flag = false;
     do
     {
       try
       {
         if (this.ReadForType(reader, contractSafe, converter != null))
         {
           switch (reader.TokenType)
           {
             case JsonToken.Comment:
               break;
             case JsonToken.EndArray:
               flag = true;
               break;
             default:
               object obj = converter == null || !converter.CanRead ? this.CreateValueInternal(reader, contract.CollectionItemType, contractSafe, (JsonProperty) null, (JsonContainerContract) contract, containerProperty, (object) null) : converter.ReadJson(reader, contract.CollectionItemType, (object) null, (JsonSerializer) this.GetInternalSerializer());
               wrappedList.Add(obj);
               break;
           }
         }
         else
           break;
       }
       catch (Exception ex)
       {
         JsonPosition position = reader.GetPosition(depth);
         if (this.IsErrorHandled(underlyingCollection, (JsonContract) contract, (object) position.Position, reader.Path, ex))
         {
           this.HandleError(reader, true, depth);
           if (nullable1.HasValue)
           {
             int? nullable2 = nullable1;
             int? nullable3 = position.Position;
             if ((nullable2.GetValueOrDefault() != nullable3.GetValueOrDefault() ? 0 : (nullable2.HasValue == nullable3.HasValue ? 1 : 0)) != 0)
               throw JsonSerializationException.Create(reader, "Infinite loop detected from error handling.", ex);
           }
           nullable1 = position.Position;
         }
         else
           throw;
       }
     }
     while (!flag);
     if (!flag)
       this.ThrowUnexpectedEndException(reader, (JsonContract) contract, underlyingCollection, "Unexpected end when deserializing array.");
     contract.InvokeOnDeserialized(underlyingCollection, this.Serializer.Context);
     return underlyingCollection;
   }
 }
 private object PopulateMultidimensionalArray(IList list, JsonReader reader, JsonArrayContract contract, JsonProperty containerProperty, string id)
 {
   int arrayRank = contract.UnderlyingType.GetArrayRank();
   if (id != null)
     this.AddReference(reader, id, (object) list);
   contract.InvokeOnDeserializing((object) list, this.Serializer.Context);
   JsonContract contractSafe = this.GetContractSafe(contract.CollectionItemType);
   JsonConverter converter = this.GetConverter(contractSafe, (JsonConverter) null, (JsonContainerContract) contract, containerProperty);
   int? nullable1 = new int?();
   Stack<IList> stack = new Stack<IList>();
   stack.Push(list);
   IList list1 = list;
   bool flag = false;
   do
   {
     int depth = reader.Depth;
     if (stack.Count == arrayRank)
     {
       try
       {
         if (this.ReadForType(reader, contractSafe, converter != null))
         {
           switch (reader.TokenType)
           {
             case JsonToken.Comment:
               break;
             case JsonToken.EndArray:
               stack.Pop();
               list1 = stack.Peek();
               nullable1 = new int?();
               break;
             default:
               object obj = converter == null || !converter.CanRead ? this.CreateValueInternal(reader, contract.CollectionItemType, contractSafe, (JsonProperty) null, (JsonContainerContract) contract, containerProperty, (object) null) : converter.ReadJson(reader, contract.CollectionItemType, (object) null, (JsonSerializer) this.GetInternalSerializer());
               list1.Add(obj);
               break;
           }
         }
         else
           break;
       }
       catch (Exception ex)
       {
         JsonPosition position = reader.GetPosition(depth);
         if (this.IsErrorHandled((object) list, (JsonContract) contract, (object) position.Position, reader.Path, ex))
         {
           this.HandleError(reader, true, depth);
           if (nullable1.HasValue)
           {
             int? nullable2 = nullable1;
             int? nullable3 = position.Position;
             if ((nullable2.GetValueOrDefault() != nullable3.GetValueOrDefault() ? 0 : (nullable2.HasValue == nullable3.HasValue ? 1 : 0)) != 0)
               throw JsonSerializationException.Create(reader, "Infinite loop detected from error handling.", ex);
           }
           nullable1 = position.Position;
         }
         else
           throw;
       }
     }
     else if (reader.Read())
     {
       switch (reader.TokenType)
       {
         case JsonToken.StartArray:
           IList list2 = (IList) new List<object>();
           list1.Add((object) list2);
           stack.Push(list2);
           list1 = list2;
           break;
         case JsonToken.Comment:
           break;
         case JsonToken.EndArray:
           stack.Pop();
           if (stack.Count > 0)
           {
             list1 = stack.Peek();
             break;
           }
           else
           {
             flag = true;
             break;
           }
         default:
           throw JsonSerializationException.Create(reader, "Unexpected token when deserializing multidimensional array: " + (object) reader.TokenType);
       }
     }
     else
       break;
   }
   while (!flag);
   if (!flag)
     this.ThrowUnexpectedEndException(reader, (JsonContract) contract, (object) list, "Unexpected end when deserializing array.");
   contract.InvokeOnDeserialized((object) list, this.Serializer.Context);
   return (object) list;
 }
        private IList PopulateList(IList list, JsonReader reader, string reference, JsonArrayContract contract)
        {
            if (reference != null)
            _serializer.ReferenceResolver.AddReference(reference, list);

              contract.InvokeOnDeserializing(list);

              while (reader.Read())
              {
            switch (reader.TokenType)
            {
              case JsonToken.EndArray:
            contract.InvokeOnDeserialized(list);

            return list;
              case JsonToken.Comment:
            break;
              default:
            object value = CreateValue(reader, contract.CollectionItemType, null, null);

            list.Add(value);
            break;
            }
              }

              throw new JsonSerializationException("Unexpected end when deserializing array.");
        }
Example #12
0
        private object PopulateMultidimensionalArray(IList list, JsonReader reader, string reference, JsonArrayContract contract)
        {
            int arrayRank = contract.UnderlyingType.GetArrayRank();

            if (reference != null)
            {
                base.Serializer.ReferenceResolver.AddReference(this, reference, list);
            }
            contract.InvokeOnDeserializing(list, base.Serializer.Context);
            Stack <IList> stack = new Stack <IList>();

            stack.Push(list);
            IList list2 = list;
            bool  flag  = false;

            do
            {
                int depth = reader.Depth;
                if (stack.Count == arrayRank)
                {
                    if (!ReadForTypeArrayHack(reader, contract.CollectionItemType))
                    {
                        break;
                    }
                    switch (reader.TokenType)
                    {
                    case JsonToken.EndArray:
                        stack.Pop();
                        list2 = stack.Peek();
                        continue;

                    case JsonToken.Comment:
                        continue;
                    }
                    try
                    {
                        object value = CreateValueNonProperty(reader, contract.CollectionItemType, GetContractSafe(contract.CollectionItemType));
                        list2.Add(value);
                    }
                    catch (Exception ex)
                    {
                        if (IsErrorHandled(list, contract, list2.Count, ex))
                        {
                            HandleError(reader, depth);
                            continue;
                        }
                        throw;
                    }
                    continue;
                }
                if (!reader.Read())
                {
                    break;
                }
                switch (reader.TokenType)
                {
                case JsonToken.StartArray:
                {
                    IList list3 = new List <object>();
                    list2.Add(list3);
                    stack.Push(list3);
                    list2 = list3;
                    break;
                }

                case JsonToken.EndArray:
                    stack.Pop();
                    if (stack.Count > 0)
                    {
                        list2 = stack.Peek();
                    }
                    else
                    {
                        flag = true;
                    }
                    break;

                default:
                    throw new JsonSerializationException("Unexpected token when deserializing multidimensional array: " + reader.TokenType);

                case JsonToken.Comment:
                    break;
                }
            }while (!flag);
            if (!flag)
            {
                throw new JsonSerializationException("Unexpected end when deserializing array." + reader.TokenType);
            }
            contract.InvokeOnDeserialized(list, base.Serializer.Context);
            return(list);
        }