public JsonPosition(JsonContainerType type)
 {
     Type = type;
     HasIndex = TypeHasIndex(type);
     Position = -1;
     PropertyName = null;
 }

        private void AutoCompleteClose(JsonContainerType type)
        {
            // write closing symbol and calculate new state
            int levelsToComplete = 0;

            if (_currentPosition.Type == type)
            {
                levelsToComplete = 1;
            }
            else
            {
                int top = Top - 2;
                for (int i = top; i >= 0; i--)
                {
                    int currentLevel = top - i;

                    if (_stack[currentLevel].Type == type)
                    {
                        levelsToComplete = i + 2;
                        break;
                    }
                }
            }

            if (levelsToComplete == 0)
                throw JsonWriterException.Create(this, "No token to close.", null);

            for (int i = 0; i < levelsToComplete; i++)
            {
                JsonToken token = GetCloseTokenForType(Pop());

                if (_currentState == State.Property)
                    WriteNull();

                if (_formatting == Formatting.Indented)
                {
                    if (_currentState != State.ObjectStart && _currentState != State.ArrayStart)
                        WriteIndent();
                }

                WriteEnd(token);

                JsonContainerType currentLevelType = Peek();

                switch (currentLevelType)
                {
                    case JsonContainerType.Object:
                        _currentState = State.Object;
                        break;
                    case JsonContainerType.Array:
                        _currentState = State.Array;
                        break;
                    case JsonContainerType.Constructor:
                        _currentState = State.Array;
                        break;
                    case JsonContainerType.None:
                        _currentState = State.Start;
                        break;
                    default:
                        throw JsonWriterException.Create(this, "Unknown JsonType: " + currentLevelType, null);
                }
            }
        }

 private JsonToken GetCloseTokenForType(JsonContainerType type)
 {
     switch (type)
     {
         case JsonContainerType.Object:
             return JsonToken.EndObject;
         case JsonContainerType.Array:
             return JsonToken.EndArray;
         case JsonContainerType.Constructor:
             return JsonToken.EndConstructor;
         default:
             throw JsonWriterException.Create(this, "No close token for type: " + type, null);
     }
 }

 private void WriteEnd(JsonContainerType type)
 {
     switch (type)
     {
         case JsonContainerType.Object:
             WriteEndObject();
             break;
         case JsonContainerType.Array:
             WriteEndArray();
             break;
         case JsonContainerType.Constructor:
             WriteEndConstructor();
             break;
         default:
             throw JsonWriterException.Create(this, "Unexpected type when writing end: " + type, null);
     }
 }

        private void Push(JsonContainerType value)
        {
            if (_currentPosition.Type != JsonContainerType.None)
                _stack.Add(_currentPosition);

            _currentPosition = new JsonPosition(value);
        }

 internal void InternalWriteStart(JsonToken token, JsonContainerType container)
 {
     UpdateScopeWithFinishedValue();
     AutoComplete(token);
     Push(container);
 }

 internal void InternalWriteEnd(JsonContainerType container)
 {
     AutoCompleteClose(container);
 }

 internal static bool TypeHasIndex(JsonContainerType type)
 {
     return (type == JsonContainerType.Array || type == JsonContainerType.Constructor);
 }

        private void Push(JsonContainerType value)
        {
            UpdateScopeWithFinishedValue();

            if (_currentPosition.Type == JsonContainerType.None)
            {
                _currentPosition = new JsonPosition(value);
            }
            else
            {
                _stack.Add(_currentPosition);
                _currentPosition = new JsonPosition(value);

                // this is a little hacky because Depth increases when first property/value is written but only testing here is faster/simpler
                if (_maxDepth != null && Depth + 1 > _maxDepth && !_hasExceededMaxDepth)
                {
                    _hasExceededMaxDepth = true;
                    throw JsonReaderException.Create(this, "The reader's MaxDepth of {0} has been exceeded.".FormatWith(CultureInfo.InvariantCulture, _maxDepth));
                }
            }
        }

 private void Push(JsonContainerType value)
 {
   if (_currentPosition.Type == JsonContainerType.None)
   {
     _currentPosition.Type = value;
   }
   else
   {
     _stack.Add(_currentPosition);
     var state = new JsonPosition
     {
       Type = value
     };
     _currentPosition = state;
   }
 }

    private void Push(JsonContainerType value)
    {
      UpdateScopeWithFinishedValue();

      if (_currentPosition.Type == JsonContainerType.None)
      {
        _currentPosition.Type = value;
      }
      else
      {
        _stack.Add(_currentPosition);
        var state = new JsonPosition
        {
          Type = value
        };
        _currentPosition = state;
      }
    }

 private void AutoCompleteClose(JsonContainerType type)
 {
   int num1 = 0;
   if (this._currentPosition.Type == type)
   {
     num1 = 1;
   }
   else
   {
     int num2 = this.Top - 2;
     for (int index = num2; index >= 0; --index)
     {
       if (this._stack[num2 - index].Type == type)
       {
         num1 = index + 2;
         break;
       }
     }
   }
   if (num1 == 0)
     throw JsonWriterException.Create(this, "No token to close.", (Exception) null);
   for (int index = 0; index < num1; ++index)
   {
     JsonToken closeTokenForType = this.GetCloseTokenForType(this.Pop());
     if (this._currentState == JsonWriter.State.Property)
       this.WriteNull();
     if (this._formatting == Formatting.Indented && this._currentState != JsonWriter.State.ObjectStart && this._currentState != JsonWriter.State.ArrayStart)
       this.WriteIndent();
     this.WriteEnd(closeTokenForType);
     JsonContainerType jsonContainerType = this.Peek();
     switch (jsonContainerType)
     {
       case JsonContainerType.None:
         this._currentState = JsonWriter.State.Start;
         break;
       case JsonContainerType.Object:
         this._currentState = JsonWriter.State.Object;
         break;
       case JsonContainerType.Array:
         this._currentState = JsonWriter.State.Array;
         break;
       case JsonContainerType.Constructor:
         this._currentState = JsonWriter.State.Array;
         break;
       default:
         throw JsonWriterException.Create(this, "Unknown JsonType: " + (object) jsonContainerType, (Exception) null);
     }
   }
 }

 private void Push(JsonContainerType value)
 {
   if (this._currentPosition.Type == JsonContainerType.None)
   {
     this._currentPosition.Type = value;
   }
   else
   {
     this._stack.Add(this._currentPosition);
     this._currentPosition = new JsonPosition()
     {
       Type = value
     };
   }
 }

        private void Push(JsonContainerType value)
        {
            if (_currentPosition.Type != JsonContainerType.None)
            {
                if (_stack == null)
                {
                    _stack = new List<JsonPosition>();
                }

                _stack.Add(_currentPosition);
            }

            _currentPosition = new JsonPosition(value);
        }

 private void Push(JsonContainerType value)
 {
   this.UpdateScopeWithFinishedValue();
   if (this._currentPosition.Type == JsonContainerType.None)
   {
     this._currentPosition.Type = value;
   }
   else
   {
     this._stack.Add(this._currentPosition);
     this._currentPosition = new JsonPosition()
     {
       Type = value
     };
     if (!this._maxDepth.HasValue)
       return;
     int num = this.Depth + 1;
     int? nullable = this._maxDepth;
     if ((num <= nullable.GetValueOrDefault() ? 0 : (nullable.HasValue ? 1 : 0)) == 0 || this._hasExceededMaxDepth)
       return;
     this._hasExceededMaxDepth = true;
     throw JsonReaderException.Create(this, StringUtils.FormatWith("The reader's MaxDepth of {0} has been exceeded.", (IFormatProvider) CultureInfo.InvariantCulture, (object) this._maxDepth));
   }
 }

 // Token: 0x06000074 RID: 116
 // RVA: 0x00028D14 File Offset: 0x00026F14
 private void Push(JsonContainerType value)
 {
     this.UpdateScopeWithFinishedValue();
     if (this._currentPosition.Type == JsonContainerType.None)
     {
         this._currentPosition = new JsonPosition(value);
         return;
     }
     this._stack.Add(this._currentPosition);
     this._currentPosition = new JsonPosition(value);
     if (this._maxDepth.HasValue && this.Depth + 1 > this._maxDepth && !this._hasExceededMaxDepth)
     {
         this._hasExceededMaxDepth = true;
         throw JsonReaderException.Create(this, StringUtils.FormatWith("The reader's MaxDepth of {0} has been exceeded.", CultureInfo.InvariantCulture, this._maxDepth));
     }
 }