1 // Protocol Buffers - Google's data interchange format
2 // Copyright 2008 Google Inc. All rights reserved.
3 // http://code.google.com/p/protobuf/
4 //
5 // Redistribution and use in source and binary forms, with or without
6 // modification, are permitted provided that the following conditions are
7 // met:
8 //
9 // * Redistributions of source code must retain the above copyright
10 // notice, this list of conditions and the following disclaimer.
11 // * Redistributions in binary form must reproduce the above
12 // copyright notice, this list of conditions and the following disclaimer
13 // in the documentation and/or other materials provided with the
14 // distribution.
15 // * Neither the name of Google Inc. nor the names of its
16 // contributors may be used to endorse or promote products derived from
17 // this software without specific prior written permission.
18 //
19 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
23 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
25 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30
31 // Author: kenton@google.com (Kenton Varda)
32 // wink@google.com (Wink Saville) (refactored from wire_format.h)
33 // Based on original Protocol Buffers design by
34 // Sanjay Ghemawat, Jeff Dean, and others.
35
36 #ifndef GOOGLE_PROTOBUF_WIRE_FORMAT_LITE_INL_H__
37 #define GOOGLE_PROTOBUF_WIRE_FORMAT_LITE_INL_H__
38
39 #include <string>
40 #include <google/protobuf/stubs/common.h>
41 #include <google/protobuf/message_lite.h>
42 #include <google/protobuf/repeated_field.h>
43 #include <google/protobuf/wire_format_lite.h>
44 #include <google/protobuf/generated_message_util.h>
45 #include <google/protobuf/io/coded_stream.h>
46
47
48 namespace google {
49 namespace protobuf {
50 namespace internal {
51
52 // Implementation details of ReadPrimitive.
53
54 template <>
55 inline bool WireFormatLite::ReadPrimitive<int32, WireFormatLite::TYPE_INT32>(
56 io::CodedInputStream* input,
57 int32* value) {
58 uint32 temp;
59 if (!input->ReadVarint32(&temp)) return false;
60 *value = static_cast<int32>(temp);
61 return true;
62 }
63 template <>
64 inline bool WireFormatLite::ReadPrimitive<int64, WireFormatLite::TYPE_INT64>(
65 io::CodedInputStream* input,
66 int64* value) {
67 uint64 temp;
68 if (!input->ReadVarint64(&temp)) return false;
69 *value = static_cast<int64>(temp);
70 return true;
71 }
72 template <>
73 inline bool WireFormatLite::ReadPrimitive<uint32, WireFormatLite::TYPE_UINT32>(
74 io::CodedInputStream* input,
75 uint32* value) {
76 return input->ReadVarint32(value);
77 }
78 template <>
79 inline bool WireFormatLite::ReadPrimitive<uint64, WireFormatLite::TYPE_UINT64>(
80 io::CodedInputStream* input,
81 uint64* value) {
82 return input->ReadVarint64(value);
83 }
84 template <>
85 inline bool WireFormatLite::ReadPrimitive<int32, WireFormatLite::TYPE_SINT32>(
86 io::CodedInputStream* input,
87 int32* value) {
88 uint32 temp;
89 if (!input->ReadVarint32(&temp)) return false;
90 *value = ZigZagDecode32(temp);
91 return true;
92 }
93 template <>
94 inline bool WireFormatLite::ReadPrimitive<int64, WireFormatLite::TYPE_SINT64>(
95 io::CodedInputStream* input,
96 int64* value) {
97 uint64 temp;
98 if (!input->ReadVarint64(&temp)) return false;
99 *value = ZigZagDecode64(temp);
100 return true;
101 }
102 template <>
103 inline bool WireFormatLite::ReadPrimitive<uint32, WireFormatLite::TYPE_FIXED32>(
104 io::CodedInputStream* input,
105 uint32* value) {
106 return input->ReadLittleEndian32(value);
107 }
108 template <>
109 inline bool WireFormatLite::ReadPrimitive<uint64, WireFormatLite::TYPE_FIXED64>(
110 io::CodedInputStream* input,
111 uint64* value) {
112 return input->ReadLittleEndian64(value);
113 }
114 template <>
115 inline bool WireFormatLite::ReadPrimitive<int32, WireFormatLite::TYPE_SFIXED32>(
116 io::CodedInputStream* input,
117 int32* value) {
118 uint32 temp;
119 if (!input->ReadLittleEndian32(&temp)) return false;
120 *value = static_cast<int32>(temp);
121 return true;
122 }
123 template <>
124 inline bool WireFormatLite::ReadPrimitive<int64, WireFormatLite::TYPE_SFIXED64>(
125 io::CodedInputStream* input,
126 int64* value) {
127 uint64 temp;
128 if (!input->ReadLittleEndian64(&temp)) return false;
129 *value = static_cast<int64>(temp);
130 return true;
131 }
132 template <>
133 inline bool WireFormatLite::ReadPrimitive<float, WireFormatLite::TYPE_FLOAT>(
134 io::CodedInputStream* input,
135 float* value) {
136 uint32 temp;
137 if (!input->ReadLittleEndian32(&temp)) return false;
138 *value = DecodeFloat(temp);
139 return true;
140 }
141 template <>
142 inline bool WireFormatLite::ReadPrimitive<double, WireFormatLite::TYPE_DOUBLE>(
143 io::CodedInputStream* input,
144 double* value) {
145 uint64 temp;
146 if (!input->ReadLittleEndian64(&temp)) return false;
147 *value = DecodeDouble(temp);
148 return true;
149 }
150 template <>
151 inline bool WireFormatLite::ReadPrimitive<bool, WireFormatLite::TYPE_BOOL>(
152 io::CodedInputStream* input,
153 bool* value) {
154 uint32 temp;
155 if (!input->ReadVarint32(&temp)) return false;
156 *value = temp != 0;
157 return true;
158 }
159 template <>
160 inline bool WireFormatLite::ReadPrimitive<int, WireFormatLite::TYPE_ENUM>(
161 io::CodedInputStream* input,
162 int* value) {
163 uint32 temp;
164 if (!input->ReadVarint32(&temp)) return false;
165 *value = static_cast<int>(temp);
166 return true;
167 }
168
169 template <>
170 inline const uint8* WireFormatLite::ReadPrimitiveFromArray<
171 uint32, WireFormatLite::TYPE_FIXED32>(
172 const uint8* buffer,
173 uint32* value) {
174 return io::CodedInputStream::ReadLittleEndian32FromArray(buffer, value);
175 }
176 template <>
177 inline const uint8* WireFormatLite::ReadPrimitiveFromArray<
178 uint64, WireFormatLite::TYPE_FIXED64>(
179 const uint8* buffer,
180 uint64* value) {
181 return io::CodedInputStream::ReadLittleEndian64FromArray(buffer, value);
182 }
183 template <>
184 inline const uint8* WireFormatLite::ReadPrimitiveFromArray<
185 int32, WireFormatLite::TYPE_SFIXED32>(
186 const uint8* buffer,
187 int32* value) {
188 uint32 temp;
189 buffer = io::CodedInputStream::ReadLittleEndian32FromArray(buffer, &temp);
190 *value = static_cast<int32>(temp);
191 return buffer;
192 }
193 template <>
194 inline const uint8* WireFormatLite::ReadPrimitiveFromArray<
195 int64, WireFormatLite::TYPE_SFIXED64>(
196 const uint8* buffer,
197 int64* value) {
198 uint64 temp;
199 buffer = io::CodedInputStream::ReadLittleEndian64FromArray(buffer, &temp);
200 *value = static_cast<int64>(temp);
201 return buffer;
202 }
203 template <>
204 inline const uint8* WireFormatLite::ReadPrimitiveFromArray<
205 float, WireFormatLite::TYPE_FLOAT>(
206 const uint8* buffer,
207 float* value) {
208 uint32 temp;
209 buffer = io::CodedInputStream::ReadLittleEndian32FromArray(buffer, &temp);
210 *value = DecodeFloat(temp);
211 return buffer;
212 }
213 template <>
214 inline const uint8* WireFormatLite::ReadPrimitiveFromArray<
215 double, WireFormatLite::TYPE_DOUBLE>(
216 const uint8* buffer,
217 double* value) {
218 uint64 temp;
219 buffer = io::CodedInputStream::ReadLittleEndian64FromArray(buffer, &temp);
220 *value = DecodeDouble(temp);
221 return buffer;
222 }
223
224 template <typename CType, enum WireFormatLite::FieldType DeclaredType>
ReadRepeatedPrimitive(int tag_size,uint32 tag,io::CodedInputStream * input,RepeatedField<CType> * values)225 inline bool WireFormatLite::ReadRepeatedPrimitive(int tag_size,
226 uint32 tag,
227 io::CodedInputStream* input,
228 RepeatedField<CType>* values) {
229 CType value;
230 if (!ReadPrimitive<CType, DeclaredType>(input, &value)) return false;
231 values->Add(value);
232 int elements_already_reserved = values->Capacity() - values->size();
233 while (elements_already_reserved > 0 && input->ExpectTag(tag)) {
234 if (!ReadPrimitive<CType, DeclaredType>(input, &value)) return false;
235 values->AddAlreadyReserved(value);
236 elements_already_reserved--;
237 }
238 return true;
239 }
240
241 template <typename CType, enum WireFormatLite::FieldType DeclaredType>
ReadRepeatedFixedSizePrimitive(int tag_size,uint32 tag,io::CodedInputStream * input,RepeatedField<CType> * values)242 inline bool WireFormatLite::ReadRepeatedFixedSizePrimitive(
243 int tag_size,
244 uint32 tag,
245 io::CodedInputStream* input,
246 RepeatedField<CType>* values) {
247 GOOGLE_DCHECK_EQ(UInt32Size(tag), tag_size);
248 CType value;
249 if (!ReadPrimitive<CType, DeclaredType>(input, &value))
250 return false;
251 values->Add(value);
252
253 // For fixed size values, repeated values can be read more quickly by
254 // reading directly from a raw array.
255 //
256 // We can get a tight loop by only reading as many elements as can be
257 // added to the RepeatedField without having to do any resizing. Additionally,
258 // we only try to read as many elements as are available from the current
259 // buffer space. Doing so avoids having to perform boundary checks when
260 // reading the value: the maximum number of elements that can be read is
261 // known outside of the loop.
262 const void* void_pointer;
263 int size;
264 input->GetDirectBufferPointerInline(&void_pointer, &size);
265 if (size > 0) {
266 const uint8* buffer = reinterpret_cast<const uint8*>(void_pointer);
267 // The number of bytes each type occupies on the wire.
268 const int per_value_size = tag_size + sizeof(value);
269
270 int elements_available = min(values->Capacity() - values->size(),
271 size / per_value_size);
272 int num_read = 0;
273 while (num_read < elements_available &&
274 (buffer = io::CodedInputStream::ExpectTagFromArray(
275 buffer, tag)) != NULL) {
276 buffer = ReadPrimitiveFromArray<CType, DeclaredType>(buffer, &value);
277 values->AddAlreadyReserved(value);
278 ++num_read;
279 }
280 const int read_bytes = num_read * per_value_size;
281 if (read_bytes > 0) {
282 input->Skip(read_bytes);
283 }
284 }
285 return true;
286 }
287
288 // Specializations of ReadRepeatedPrimitive for the fixed size types, which use
289 // the optimized code path.
290 #define READ_REPEATED_FIXED_SIZE_PRIMITIVE(CPPTYPE, DECLARED_TYPE) \
291 template <> \
292 inline bool WireFormatLite::ReadRepeatedPrimitive< \
293 CPPTYPE, WireFormatLite::DECLARED_TYPE>( \
294 int tag_size, \
295 uint32 tag, \
296 io::CodedInputStream* input, \
297 RepeatedField<CPPTYPE>* values) { \
298 return ReadRepeatedFixedSizePrimitive< \
299 CPPTYPE, WireFormatLite::DECLARED_TYPE>( \
300 tag_size, tag, input, values); \
301 }
302
303 READ_REPEATED_FIXED_SIZE_PRIMITIVE(uint32, TYPE_FIXED32);
304 READ_REPEATED_FIXED_SIZE_PRIMITIVE(uint64, TYPE_FIXED64);
305 READ_REPEATED_FIXED_SIZE_PRIMITIVE(int32, TYPE_SFIXED32);
306 READ_REPEATED_FIXED_SIZE_PRIMITIVE(int64, TYPE_SFIXED64);
307 READ_REPEATED_FIXED_SIZE_PRIMITIVE(float, TYPE_FLOAT);
308 READ_REPEATED_FIXED_SIZE_PRIMITIVE(double, TYPE_DOUBLE);
309
310 #undef READ_REPEATED_FIXED_SIZE_PRIMITIVE
311
312 template <typename CType, enum WireFormatLite::FieldType DeclaredType>
ReadRepeatedPrimitiveNoInline(int tag_size,uint32 tag,io::CodedInputStream * input,RepeatedField<CType> * value)313 bool WireFormatLite::ReadRepeatedPrimitiveNoInline(
314 int tag_size,
315 uint32 tag,
316 io::CodedInputStream* input,
317 RepeatedField<CType>* value) {
318 return ReadRepeatedPrimitive<CType, DeclaredType>(
319 tag_size, tag, input, value);
320 }
321
322 template <typename CType, enum WireFormatLite::FieldType DeclaredType>
ReadPackedPrimitive(io::CodedInputStream * input,RepeatedField<CType> * values)323 inline bool WireFormatLite::ReadPackedPrimitive(io::CodedInputStream* input,
324 RepeatedField<CType>* values) {
325 uint32 length;
326 if (!input->ReadVarint32(&length)) return false;
327 io::CodedInputStream::Limit limit = input->PushLimit(length);
328 while (input->BytesUntilLimit() > 0) {
329 CType value;
330 if (!ReadPrimitive<CType, DeclaredType>(input, &value)) return false;
331 values->Add(value);
332 }
333 input->PopLimit(limit);
334 return true;
335 }
336
337 template <typename CType, enum WireFormatLite::FieldType DeclaredType>
ReadPackedPrimitiveNoInline(io::CodedInputStream * input,RepeatedField<CType> * values)338 bool WireFormatLite::ReadPackedPrimitiveNoInline(io::CodedInputStream* input,
339 RepeatedField<CType>* values) {
340 return ReadPackedPrimitive<CType, DeclaredType>(input, values);
341 }
342
343
ReadGroup(int field_number,io::CodedInputStream * input,MessageLite * value)344 inline bool WireFormatLite::ReadGroup(int field_number,
345 io::CodedInputStream* input,
346 MessageLite* value) {
347 if (!input->IncrementRecursionDepth()) return false;
348 if (!value->MergePartialFromCodedStream(input)) return false;
349 input->DecrementRecursionDepth();
350 // Make sure the last thing read was an end tag for this group.
351 if (!input->LastTagWas(MakeTag(field_number, WIRETYPE_END_GROUP))) {
352 return false;
353 }
354 return true;
355 }
ReadMessage(io::CodedInputStream * input,MessageLite * value)356 inline bool WireFormatLite::ReadMessage(io::CodedInputStream* input,
357 MessageLite* value) {
358 uint32 length;
359 if (!input->ReadVarint32(&length)) return false;
360 if (!input->IncrementRecursionDepth()) return false;
361 io::CodedInputStream::Limit limit = input->PushLimit(length);
362 if (!value->MergePartialFromCodedStream(input)) return false;
363 // Make sure that parsing stopped when the limit was hit, not at an endgroup
364 // tag.
365 if (!input->ConsumedEntireMessage()) return false;
366 input->PopLimit(limit);
367 input->DecrementRecursionDepth();
368 return true;
369 }
370
371 template<typename MessageType>
ReadGroupNoVirtual(int field_number,io::CodedInputStream * input,MessageType * value)372 inline bool WireFormatLite::ReadGroupNoVirtual(int field_number,
373 io::CodedInputStream* input,
374 MessageType* value) {
375 if (!input->IncrementRecursionDepth()) return false;
376 if (!value->MessageType::MergePartialFromCodedStream(input)) return false;
377 input->DecrementRecursionDepth();
378 // Make sure the last thing read was an end tag for this group.
379 if (!input->LastTagWas(MakeTag(field_number, WIRETYPE_END_GROUP))) {
380 return false;
381 }
382 return true;
383 }
384 template<typename MessageType>
ReadMessageNoVirtual(io::CodedInputStream * input,MessageType * value)385 inline bool WireFormatLite::ReadMessageNoVirtual(io::CodedInputStream* input,
386 MessageType* value) {
387 uint32 length;
388 if (!input->ReadVarint32(&length)) return false;
389 if (!input->IncrementRecursionDepth()) return false;
390 io::CodedInputStream::Limit limit = input->PushLimit(length);
391 if (!value->MessageType::MergePartialFromCodedStream(input)) return false;
392 // Make sure that parsing stopped when the limit was hit, not at an endgroup
393 // tag.
394 if (!input->ConsumedEntireMessage()) return false;
395 input->PopLimit(limit);
396 input->DecrementRecursionDepth();
397 return true;
398 }
399
400 // ===================================================================
401
WriteTag(int field_number,WireType type,io::CodedOutputStream * output)402 inline void WireFormatLite::WriteTag(int field_number, WireType type,
403 io::CodedOutputStream* output) {
404 output->WriteTag(MakeTag(field_number, type));
405 }
406
WriteInt32NoTag(int32 value,io::CodedOutputStream * output)407 inline void WireFormatLite::WriteInt32NoTag(int32 value,
408 io::CodedOutputStream* output) {
409 output->WriteVarint32SignExtended(value);
410 }
WriteInt64NoTag(int64 value,io::CodedOutputStream * output)411 inline void WireFormatLite::WriteInt64NoTag(int64 value,
412 io::CodedOutputStream* output) {
413 output->WriteVarint64(static_cast<uint64>(value));
414 }
WriteUInt32NoTag(uint32 value,io::CodedOutputStream * output)415 inline void WireFormatLite::WriteUInt32NoTag(uint32 value,
416 io::CodedOutputStream* output) {
417 output->WriteVarint32(value);
418 }
WriteUInt64NoTag(uint64 value,io::CodedOutputStream * output)419 inline void WireFormatLite::WriteUInt64NoTag(uint64 value,
420 io::CodedOutputStream* output) {
421 output->WriteVarint64(value);
422 }
WriteSInt32NoTag(int32 value,io::CodedOutputStream * output)423 inline void WireFormatLite::WriteSInt32NoTag(int32 value,
424 io::CodedOutputStream* output) {
425 output->WriteVarint32(ZigZagEncode32(value));
426 }
WriteSInt64NoTag(int64 value,io::CodedOutputStream * output)427 inline void WireFormatLite::WriteSInt64NoTag(int64 value,
428 io::CodedOutputStream* output) {
429 output->WriteVarint64(ZigZagEncode64(value));
430 }
WriteFixed32NoTag(uint32 value,io::CodedOutputStream * output)431 inline void WireFormatLite::WriteFixed32NoTag(uint32 value,
432 io::CodedOutputStream* output) {
433 output->WriteLittleEndian32(value);
434 }
WriteFixed64NoTag(uint64 value,io::CodedOutputStream * output)435 inline void WireFormatLite::WriteFixed64NoTag(uint64 value,
436 io::CodedOutputStream* output) {
437 output->WriteLittleEndian64(value);
438 }
WriteSFixed32NoTag(int32 value,io::CodedOutputStream * output)439 inline void WireFormatLite::WriteSFixed32NoTag(int32 value,
440 io::CodedOutputStream* output) {
441 output->WriteLittleEndian32(static_cast<uint32>(value));
442 }
WriteSFixed64NoTag(int64 value,io::CodedOutputStream * output)443 inline void WireFormatLite::WriteSFixed64NoTag(int64 value,
444 io::CodedOutputStream* output) {
445 output->WriteLittleEndian64(static_cast<uint64>(value));
446 }
WriteFloatNoTag(float value,io::CodedOutputStream * output)447 inline void WireFormatLite::WriteFloatNoTag(float value,
448 io::CodedOutputStream* output) {
449 output->WriteLittleEndian32(EncodeFloat(value));
450 }
WriteDoubleNoTag(double value,io::CodedOutputStream * output)451 inline void WireFormatLite::WriteDoubleNoTag(double value,
452 io::CodedOutputStream* output) {
453 output->WriteLittleEndian64(EncodeDouble(value));
454 }
WriteBoolNoTag(bool value,io::CodedOutputStream * output)455 inline void WireFormatLite::WriteBoolNoTag(bool value,
456 io::CodedOutputStream* output) {
457 output->WriteVarint32(value ? 1 : 0);
458 }
WriteEnumNoTag(int value,io::CodedOutputStream * output)459 inline void WireFormatLite::WriteEnumNoTag(int value,
460 io::CodedOutputStream* output) {
461 output->WriteVarint32SignExtended(value);
462 }
463
464 template<typename MessageType>
WriteGroupNoVirtual(int field_number,const MessageType & value,io::CodedOutputStream * output)465 inline void WireFormatLite::WriteGroupNoVirtual(int field_number,
466 const MessageType& value,
467 io::CodedOutputStream* output) {
468 WriteTag(field_number, WIRETYPE_START_GROUP, output);
469 value.MessageType::SerializeWithCachedSizes(output);
470 WriteTag(field_number, WIRETYPE_END_GROUP, output);
471 }
472 template<typename MessageType>
WriteMessageNoVirtual(int field_number,const MessageType & value,io::CodedOutputStream * output)473 inline void WireFormatLite::WriteMessageNoVirtual(int field_number,
474 const MessageType& value,
475 io::CodedOutputStream* output) {
476 WriteTag(field_number, WIRETYPE_LENGTH_DELIMITED, output);
477 output->WriteVarint32(value.MessageType::GetCachedSize());
478 value.MessageType::SerializeWithCachedSizes(output);
479 }
480
481 // ===================================================================
482
WriteTagToArray(int field_number,WireType type,uint8 * target)483 inline uint8* WireFormatLite::WriteTagToArray(int field_number,
484 WireType type,
485 uint8* target) {
486 return io::CodedOutputStream::WriteTagToArray(MakeTag(field_number, type),
487 target);
488 }
489
WriteInt32NoTagToArray(int32 value,uint8 * target)490 inline uint8* WireFormatLite::WriteInt32NoTagToArray(int32 value,
491 uint8* target) {
492 return io::CodedOutputStream::WriteVarint32SignExtendedToArray(value, target);
493 }
WriteInt64NoTagToArray(int64 value,uint8 * target)494 inline uint8* WireFormatLite::WriteInt64NoTagToArray(int64 value,
495 uint8* target) {
496 return io::CodedOutputStream::WriteVarint64ToArray(
497 static_cast<uint64>(value), target);
498 }
WriteUInt32NoTagToArray(uint32 value,uint8 * target)499 inline uint8* WireFormatLite::WriteUInt32NoTagToArray(uint32 value,
500 uint8* target) {
501 return io::CodedOutputStream::WriteVarint32ToArray(value, target);
502 }
WriteUInt64NoTagToArray(uint64 value,uint8 * target)503 inline uint8* WireFormatLite::WriteUInt64NoTagToArray(uint64 value,
504 uint8* target) {
505 return io::CodedOutputStream::WriteVarint64ToArray(value, target);
506 }
WriteSInt32NoTagToArray(int32 value,uint8 * target)507 inline uint8* WireFormatLite::WriteSInt32NoTagToArray(int32 value,
508 uint8* target) {
509 return io::CodedOutputStream::WriteVarint32ToArray(ZigZagEncode32(value),
510 target);
511 }
WriteSInt64NoTagToArray(int64 value,uint8 * target)512 inline uint8* WireFormatLite::WriteSInt64NoTagToArray(int64 value,
513 uint8* target) {
514 return io::CodedOutputStream::WriteVarint64ToArray(ZigZagEncode64(value),
515 target);
516 }
WriteFixed32NoTagToArray(uint32 value,uint8 * target)517 inline uint8* WireFormatLite::WriteFixed32NoTagToArray(uint32 value,
518 uint8* target) {
519 return io::CodedOutputStream::WriteLittleEndian32ToArray(value, target);
520 }
WriteFixed64NoTagToArray(uint64 value,uint8 * target)521 inline uint8* WireFormatLite::WriteFixed64NoTagToArray(uint64 value,
522 uint8* target) {
523 return io::CodedOutputStream::WriteLittleEndian64ToArray(value, target);
524 }
WriteSFixed32NoTagToArray(int32 value,uint8 * target)525 inline uint8* WireFormatLite::WriteSFixed32NoTagToArray(int32 value,
526 uint8* target) {
527 return io::CodedOutputStream::WriteLittleEndian32ToArray(
528 static_cast<uint32>(value), target);
529 }
WriteSFixed64NoTagToArray(int64 value,uint8 * target)530 inline uint8* WireFormatLite::WriteSFixed64NoTagToArray(int64 value,
531 uint8* target) {
532 return io::CodedOutputStream::WriteLittleEndian64ToArray(
533 static_cast<uint64>(value), target);
534 }
WriteFloatNoTagToArray(float value,uint8 * target)535 inline uint8* WireFormatLite::WriteFloatNoTagToArray(float value,
536 uint8* target) {
537 return io::CodedOutputStream::WriteLittleEndian32ToArray(EncodeFloat(value),
538 target);
539 }
WriteDoubleNoTagToArray(double value,uint8 * target)540 inline uint8* WireFormatLite::WriteDoubleNoTagToArray(double value,
541 uint8* target) {
542 return io::CodedOutputStream::WriteLittleEndian64ToArray(EncodeDouble(value),
543 target);
544 }
WriteBoolNoTagToArray(bool value,uint8 * target)545 inline uint8* WireFormatLite::WriteBoolNoTagToArray(bool value,
546 uint8* target) {
547 return io::CodedOutputStream::WriteVarint32ToArray(value ? 1 : 0, target);
548 }
WriteEnumNoTagToArray(int value,uint8 * target)549 inline uint8* WireFormatLite::WriteEnumNoTagToArray(int value,
550 uint8* target) {
551 return io::CodedOutputStream::WriteVarint32SignExtendedToArray(value, target);
552 }
553
WriteInt32ToArray(int field_number,int32 value,uint8 * target)554 inline uint8* WireFormatLite::WriteInt32ToArray(int field_number,
555 int32 value,
556 uint8* target) {
557 target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
558 return WriteInt32NoTagToArray(value, target);
559 }
WriteInt64ToArray(int field_number,int64 value,uint8 * target)560 inline uint8* WireFormatLite::WriteInt64ToArray(int field_number,
561 int64 value,
562 uint8* target) {
563 target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
564 return WriteInt64NoTagToArray(value, target);
565 }
WriteUInt32ToArray(int field_number,uint32 value,uint8 * target)566 inline uint8* WireFormatLite::WriteUInt32ToArray(int field_number,
567 uint32 value,
568 uint8* target) {
569 target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
570 return WriteUInt32NoTagToArray(value, target);
571 }
WriteUInt64ToArray(int field_number,uint64 value,uint8 * target)572 inline uint8* WireFormatLite::WriteUInt64ToArray(int field_number,
573 uint64 value,
574 uint8* target) {
575 target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
576 return WriteUInt64NoTagToArray(value, target);
577 }
WriteSInt32ToArray(int field_number,int32 value,uint8 * target)578 inline uint8* WireFormatLite::WriteSInt32ToArray(int field_number,
579 int32 value,
580 uint8* target) {
581 target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
582 return WriteSInt32NoTagToArray(value, target);
583 }
WriteSInt64ToArray(int field_number,int64 value,uint8 * target)584 inline uint8* WireFormatLite::WriteSInt64ToArray(int field_number,
585 int64 value,
586 uint8* target) {
587 target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
588 return WriteSInt64NoTagToArray(value, target);
589 }
WriteFixed32ToArray(int field_number,uint32 value,uint8 * target)590 inline uint8* WireFormatLite::WriteFixed32ToArray(int field_number,
591 uint32 value,
592 uint8* target) {
593 target = WriteTagToArray(field_number, WIRETYPE_FIXED32, target);
594 return WriteFixed32NoTagToArray(value, target);
595 }
WriteFixed64ToArray(int field_number,uint64 value,uint8 * target)596 inline uint8* WireFormatLite::WriteFixed64ToArray(int field_number,
597 uint64 value,
598 uint8* target) {
599 target = WriteTagToArray(field_number, WIRETYPE_FIXED64, target);
600 return WriteFixed64NoTagToArray(value, target);
601 }
WriteSFixed32ToArray(int field_number,int32 value,uint8 * target)602 inline uint8* WireFormatLite::WriteSFixed32ToArray(int field_number,
603 int32 value,
604 uint8* target) {
605 target = WriteTagToArray(field_number, WIRETYPE_FIXED32, target);
606 return WriteSFixed32NoTagToArray(value, target);
607 }
WriteSFixed64ToArray(int field_number,int64 value,uint8 * target)608 inline uint8* WireFormatLite::WriteSFixed64ToArray(int field_number,
609 int64 value,
610 uint8* target) {
611 target = WriteTagToArray(field_number, WIRETYPE_FIXED64, target);
612 return WriteSFixed64NoTagToArray(value, target);
613 }
WriteFloatToArray(int field_number,float value,uint8 * target)614 inline uint8* WireFormatLite::WriteFloatToArray(int field_number,
615 float value,
616 uint8* target) {
617 target = WriteTagToArray(field_number, WIRETYPE_FIXED32, target);
618 return WriteFloatNoTagToArray(value, target);
619 }
WriteDoubleToArray(int field_number,double value,uint8 * target)620 inline uint8* WireFormatLite::WriteDoubleToArray(int field_number,
621 double value,
622 uint8* target) {
623 target = WriteTagToArray(field_number, WIRETYPE_FIXED64, target);
624 return WriteDoubleNoTagToArray(value, target);
625 }
WriteBoolToArray(int field_number,bool value,uint8 * target)626 inline uint8* WireFormatLite::WriteBoolToArray(int field_number,
627 bool value,
628 uint8* target) {
629 target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
630 return WriteBoolNoTagToArray(value, target);
631 }
WriteEnumToArray(int field_number,int value,uint8 * target)632 inline uint8* WireFormatLite::WriteEnumToArray(int field_number,
633 int value,
634 uint8* target) {
635 target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
636 return WriteEnumNoTagToArray(value, target);
637 }
638
WriteStringToArray(int field_number,const string & value,uint8 * target)639 inline uint8* WireFormatLite::WriteStringToArray(int field_number,
640 const string& value,
641 uint8* target) {
642 // String is for UTF-8 text only
643 // WARNING: In wire_format.cc, both strings and bytes are handled by
644 // WriteString() to avoid code duplication. If the implementations become
645 // different, you will need to update that usage.
646 target = WriteTagToArray(field_number, WIRETYPE_LENGTH_DELIMITED, target);
647 target = io::CodedOutputStream::WriteVarint32ToArray(value.size(), target);
648 return io::CodedOutputStream::WriteStringToArray(value, target);
649 }
WriteBytesToArray(int field_number,const string & value,uint8 * target)650 inline uint8* WireFormatLite::WriteBytesToArray(int field_number,
651 const string& value,
652 uint8* target) {
653 target = WriteTagToArray(field_number, WIRETYPE_LENGTH_DELIMITED, target);
654 target = io::CodedOutputStream::WriteVarint32ToArray(value.size(), target);
655 return io::CodedOutputStream::WriteStringToArray(value, target);
656 }
657
658
WriteGroupToArray(int field_number,const MessageLite & value,uint8 * target)659 inline uint8* WireFormatLite::WriteGroupToArray(int field_number,
660 const MessageLite& value,
661 uint8* target) {
662 target = WriteTagToArray(field_number, WIRETYPE_START_GROUP, target);
663 target = value.SerializeWithCachedSizesToArray(target);
664 return WriteTagToArray(field_number, WIRETYPE_END_GROUP, target);
665 }
WriteMessageToArray(int field_number,const MessageLite & value,uint8 * target)666 inline uint8* WireFormatLite::WriteMessageToArray(int field_number,
667 const MessageLite& value,
668 uint8* target) {
669 target = WriteTagToArray(field_number, WIRETYPE_LENGTH_DELIMITED, target);
670 target = io::CodedOutputStream::WriteVarint32ToArray(
671 value.GetCachedSize(), target);
672 return value.SerializeWithCachedSizesToArray(target);
673 }
674
675 template<typename MessageType>
WriteGroupNoVirtualToArray(int field_number,const MessageType & value,uint8 * target)676 inline uint8* WireFormatLite::WriteGroupNoVirtualToArray(
677 int field_number, const MessageType& value, uint8* target) {
678 target = WriteTagToArray(field_number, WIRETYPE_START_GROUP, target);
679 target = value.MessageType::SerializeWithCachedSizesToArray(target);
680 return WriteTagToArray(field_number, WIRETYPE_END_GROUP, target);
681 }
682 template<typename MessageType>
WriteMessageNoVirtualToArray(int field_number,const MessageType & value,uint8 * target)683 inline uint8* WireFormatLite::WriteMessageNoVirtualToArray(
684 int field_number, const MessageType& value, uint8* target) {
685 target = WriteTagToArray(field_number, WIRETYPE_LENGTH_DELIMITED, target);
686 target = io::CodedOutputStream::WriteVarint32ToArray(
687 value.MessageType::GetCachedSize(), target);
688 return value.MessageType::SerializeWithCachedSizesToArray(target);
689 }
690
691 // ===================================================================
692
Int32Size(int32 value)693 inline int WireFormatLite::Int32Size(int32 value) {
694 return io::CodedOutputStream::VarintSize32SignExtended(value);
695 }
Int64Size(int64 value)696 inline int WireFormatLite::Int64Size(int64 value) {
697 return io::CodedOutputStream::VarintSize64(static_cast<uint64>(value));
698 }
UInt32Size(uint32 value)699 inline int WireFormatLite::UInt32Size(uint32 value) {
700 return io::CodedOutputStream::VarintSize32(value);
701 }
UInt64Size(uint64 value)702 inline int WireFormatLite::UInt64Size(uint64 value) {
703 return io::CodedOutputStream::VarintSize64(value);
704 }
SInt32Size(int32 value)705 inline int WireFormatLite::SInt32Size(int32 value) {
706 return io::CodedOutputStream::VarintSize32(ZigZagEncode32(value));
707 }
SInt64Size(int64 value)708 inline int WireFormatLite::SInt64Size(int64 value) {
709 return io::CodedOutputStream::VarintSize64(ZigZagEncode64(value));
710 }
EnumSize(int value)711 inline int WireFormatLite::EnumSize(int value) {
712 return io::CodedOutputStream::VarintSize32SignExtended(value);
713 }
714
StringSize(const string & value)715 inline int WireFormatLite::StringSize(const string& value) {
716 return io::CodedOutputStream::VarintSize32(value.size()) +
717 value.size();
718 }
BytesSize(const string & value)719 inline int WireFormatLite::BytesSize(const string& value) {
720 return io::CodedOutputStream::VarintSize32(value.size()) +
721 value.size();
722 }
723
724
GroupSize(const MessageLite & value)725 inline int WireFormatLite::GroupSize(const MessageLite& value) {
726 return value.ByteSize();
727 }
MessageSize(const MessageLite & value)728 inline int WireFormatLite::MessageSize(const MessageLite& value) {
729 int size = value.ByteSize();
730 return io::CodedOutputStream::VarintSize32(size) + size;
731 }
732
733 template<typename MessageType>
GroupSizeNoVirtual(const MessageType & value)734 inline int WireFormatLite::GroupSizeNoVirtual(const MessageType& value) {
735 return value.MessageType::ByteSize();
736 }
737 template<typename MessageType>
MessageSizeNoVirtual(const MessageType & value)738 inline int WireFormatLite::MessageSizeNoVirtual(const MessageType& value) {
739 int size = value.MessageType::ByteSize();
740 return io::CodedOutputStream::VarintSize32(size) + size;
741 }
742
743 } // namespace internal
744 } // namespace protobuf
745
746 } // namespace google
747 #endif // GOOGLE_PROTOBUF_WIRE_FORMAT_LITE_INL_H__
748