Lines Matching defs:value

49     /// this does not include combined "write tag and value" methods. Generated

52     /// this class should just call one of the <c>WriteTag</c> overloads before each value.

168         /// Writes a double field value, without a tag, to the stream.

170         /// <param name="value">The value to write</param>

171         public void WriteDouble(double value)

174             WritingPrimitives.WriteDouble(ref span, ref state, value);

178         /// Writes a float field value, without a tag, to the stream.

180         /// <param name="value">The value to write</param>

181         public void WriteFloat(float value)

184             WritingPrimitives.WriteFloat(ref span, ref state, value);

188         /// Writes a uint64 field value, without a tag, to the stream.

190         /// <param name="value">The value to write</param>

191         public void WriteUInt64(ulong value)

194             WritingPrimitives.WriteUInt64(ref span, ref state, value);

198         /// Writes an int64 field value, without a tag, to the stream.

200         /// <param name="value">The value to write</param>

201         public void WriteInt64(long value)

204             WritingPrimitives.WriteInt64(ref span, ref state, value);

208         /// Writes an int32 field value, without a tag, to the stream.

210         /// <param name="value">The value to write</param>

211         public void WriteInt32(int value)

214             WritingPrimitives.WriteInt32(ref span, ref state, value);

218         /// Writes a fixed64 field value, without a tag, to the stream.

220         /// <param name="value">The value to write</param>

221         public void WriteFixed64(ulong value)

224             WritingPrimitives.WriteFixed64(ref span, ref state, value);

228         /// Writes a fixed32 field value, without a tag, to the stream.

230         /// <param name="value">The value to write</param>

231         public void WriteFixed32(uint value)

234             WritingPrimitives.WriteFixed32(ref span, ref state, value);

238         /// Writes a bool field value, without a tag, to the stream.

240         /// <param name="value">The value to write</param>

241         public void WriteBool(bool value)

244             WritingPrimitives.WriteBool(ref span, ref state, value);

248         /// Writes a string field value, without a tag, to the stream.

251         /// <param name="value">The value to write</param>

252         public void WriteString(string value)

255             WritingPrimitives.WriteString(ref span, ref state, value);

262         /// <param name="value">The value to write</param>

263         public void WriteMessage(IMessage value)

272                 WritingPrimitivesMessages.WriteMessage(ref ctx, value);

284         /// <param name="value">The value to write</param>

285         public void WriteRawMessage(IMessage value)

294                 WritingPrimitivesMessages.WriteRawMessage(ref ctx, value);

305         /// <param name="value">The value to write</param>

306         public void WriteGroup(IMessage value)

312                 WritingPrimitivesMessages.WriteGroup(ref ctx, value);

324         /// <param name="value">The value to write</param>

325         public void WriteBytes(ByteString value)

328             WritingPrimitives.WriteBytes(ref span, ref state, value);

332         /// Writes a uint32 value, without a tag, to the stream.

334         /// <param name="value">The value to write</param>

335         public void WriteUInt32(uint value)

338             WritingPrimitives.WriteUInt32(ref span, ref state, value);

342         /// Writes an enum value, without a tag, to the stream.

344         /// <param name="value">The value to write</param>

345         public void WriteEnum(int value)

348             WritingPrimitives.WriteEnum(ref span, ref state, value);

352         /// Writes an sfixed32 value, without a tag, to the stream.

354         /// <param name="value">The value to write.</param>

355         public void WriteSFixed32(int value)

358             WritingPrimitives.WriteSFixed32(ref span, ref state, value);

362         /// Writes an sfixed64 value, without a tag, to the stream.

364         /// <param name="value">The value to write</param>

365         public void WriteSFixed64(long value)

368             WritingPrimitives.WriteSFixed64(ref span, ref state, value);

372         /// Writes an sint32 value, without a tag, to the stream.

374         /// <param name="value">The value to write</param>

375         public void WriteSInt32(int value)

378             WritingPrimitives.WriteSInt32(ref span, ref state, value);

382         /// Writes an sint64 value, without a tag, to the stream.

384         /// <param name="value">The value to write</param>

385         public void WriteSInt64(long value)

388             WritingPrimitives.WriteSInt64(ref span, ref state, value);

397         /// <param name="length">Length value, in bytes.</param>

492         /// Writes a 32 bit value as a varint. The fast route is taken when

496         internal void WriteRawVarint32(uint value)

499             WritingPrimitives.WriteRawVarint32(ref span, ref state, value);

502         internal void WriteRawVarint64(ulong value)

505             WritingPrimitives.WriteRawVarint64(ref span, ref state, value);

508         internal void WriteRawLittleEndian32(uint value)

511             WritingPrimitives.WriteRawLittleEndian32(ref span, ref state, value);

514         internal void WriteRawLittleEndian64(ulong value)

517             WritingPrimitives.WriteRawLittleEndian64(ref span, ref state, value);

523         internal void WriteRawBytes(byte[] value)

525             WriteRawBytes(value, 0, value.Length);

531         internal void WriteRawBytes(byte[] value, int offset, int length)

534             WritingPrimitives.WriteRawBytes(ref span, ref state, value, offset, length);