Lines Matching defs:state

78         /// The parser state is kept separately so that other parse implementations can reuse the same

81         private ParserInternalState state;

143             this.state.bufferPos = bufferPos;

144             this.state.bufferSize = bufferSize;

145             this.state.sizeLimit = DefaultSizeLimit;

146             this.state.recursionLimit = DefaultRecursionLimit;

147             SegmentedBufferHelper.Initialize(this, out this.state.segmentedBufferHelper);

150             this.state.currentLimit = int.MaxValue;

172             this.state.sizeLimit = sizeLimit;

173             this.state.recursionLimit = recursionLimit;

206                     return input.Position - ((state.bufferSize + state.bufferSizeAfterLimit) - state.bufferPos);

208                 return state.bufferPos;

216         internal uint LastTag { get { return state.lastTag; } }

229         public int SizeLimit { get { return state.sizeLimit; } }

241         public int RecursionLimit { get { return state.recursionLimit; } }

248             get { return state.DiscardUnknownFields; }

249             set { state.DiscardUnknownFields = value; }

257             get { return state.ExtensionRegistry; }

258             set { state.ExtensionRegistry = value; }

265         internal ref ParserInternalState InternalState => ref state;

292             ParsingPrimitivesMessages.CheckReadEndOfStreamTag(ref state);

306             return ParsingPrimitives.PeekTag(ref span, ref state);

321             return ParsingPrimitives.ParseTag(ref span, ref state);

340             ParsingPrimitivesMessages.SkipLastField(ref span, ref state);

349             ParsingPrimitivesMessages.SkipGroup(ref span, ref state, startGroupTag);

358             return ParsingPrimitives.ParseDouble(ref span, ref state);

367             return ParsingPrimitives.ParseFloat(ref span, ref state);

424             return ParsingPrimitives.ReadString(ref span, ref state);

435             // we will need to switch back again to CodedInputStream-based parsing (which involves copying and storing the state) to be able to

439             ParseContext.Initialize(ref span, ref state, out ParseContext ctx);

472             return ParsingPrimitives.ReadBytes(ref span, ref state);

534             return ParsingPrimitives.ParseLength(ref span, ref state);

545             return ParsingPrimitives.MaybeConsumeTag(ref span, ref state, tag);

561             return ParsingPrimitives.ParseRawVarint32(ref span, ref state);

584             return ParsingPrimitives.ParseRawVarint64(ref span, ref state);

593             return ParsingPrimitives.ParseRawLittleEndian32(ref span, ref state);

602             return ParsingPrimitives.ParseRawLittleEndian64(ref span, ref state);

616             return SegmentedBufferHelper.PushLimit(ref state, byteLimit);

624             SegmentedBufferHelper.PopLimit(ref state, oldLimit);

635                 return SegmentedBufferHelper.IsReachedLimit(ref state);

649                 return SegmentedBufferHelper.IsAtEnd(ref span, ref state);

665             return state.segmentedBufferHelper.RefillBuffer(ref span, ref state, mustSucceed);

677             return ParsingPrimitives.ReadRawBytes(ref span, ref state, size);