PageRenderTime 66ms CodeModel.GetById 13ms app.highlight 47ms RepoModel.GetById 1ms app.codeStats 1ms

/thirdparty/breakpad/third_party/protobuf/protobuf/src/google/protobuf/wire_format_lite_inl.h

http://github.com/tomahawk-player/tomahawk
C++ Header | 774 lines | 658 code | 41 blank | 75 comment | 37 complexity | 73359376530a82b4a5b388640c829092 MD5 | raw file
  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
 48namespace google {
 49namespace protobuf {
 50namespace internal {
 51
 52// Implementation details of ReadPrimitive.
 53
 54template <>
 55inline 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}
 63template <>
 64inline 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}
 72template <>
 73inline bool WireFormatLite::ReadPrimitive<uint32, WireFormatLite::TYPE_UINT32>(
 74    io::CodedInputStream* input,
 75    uint32* value) {
 76  return input->ReadVarint32(value);
 77}
 78template <>
 79inline bool WireFormatLite::ReadPrimitive<uint64, WireFormatLite::TYPE_UINT64>(
 80    io::CodedInputStream* input,
 81    uint64* value) {
 82  return input->ReadVarint64(value);
 83}
 84template <>
 85inline 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}
 93template <>
 94inline 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}
102template <>
103inline bool WireFormatLite::ReadPrimitive<uint32, WireFormatLite::TYPE_FIXED32>(
104    io::CodedInputStream* input,
105    uint32* value) {
106  return input->ReadLittleEndian32(value);
107}
108template <>
109inline bool WireFormatLite::ReadPrimitive<uint64, WireFormatLite::TYPE_FIXED64>(
110    io::CodedInputStream* input,
111    uint64* value) {
112  return input->ReadLittleEndian64(value);
113}
114template <>
115inline 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}
123template <>
124inline 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}
132template <>
133inline 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}
141template <>
142inline 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}
150template <>
151inline 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}
159template <>
160inline 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
169template <>
170inline const uint8* WireFormatLite::ReadPrimitiveFromArray<
171  uint32, WireFormatLite::TYPE_FIXED32>(
172    const uint8* buffer,
173    uint32* value) {
174  return io::CodedInputStream::ReadLittleEndian32FromArray(buffer, value);
175}
176template <>
177inline const uint8* WireFormatLite::ReadPrimitiveFromArray<
178  uint64, WireFormatLite::TYPE_FIXED64>(
179    const uint8* buffer,
180    uint64* value) {
181  return io::CodedInputStream::ReadLittleEndian64FromArray(buffer, value);
182}
183template <>
184inline 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}
193template <>
194inline 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}
203template <>
204inline 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}
213template <>
214inline 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
224template <typename CType, enum WireFormatLite::FieldType DeclaredType>
225inline bool WireFormatLite::ReadRepeatedPrimitive(int, // tag_size, unused.
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
241template <typename CType, enum WireFormatLite::FieldType DeclaredType>
242inline 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)             \
291template <>                                                                    \
292inline 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
303READ_REPEATED_FIXED_SIZE_PRIMITIVE(uint32, TYPE_FIXED32);
304READ_REPEATED_FIXED_SIZE_PRIMITIVE(uint64, TYPE_FIXED64);
305READ_REPEATED_FIXED_SIZE_PRIMITIVE(int32, TYPE_SFIXED32);
306READ_REPEATED_FIXED_SIZE_PRIMITIVE(int64, TYPE_SFIXED64);
307READ_REPEATED_FIXED_SIZE_PRIMITIVE(float, TYPE_FLOAT);
308READ_REPEATED_FIXED_SIZE_PRIMITIVE(double, TYPE_DOUBLE);
309
310#undef READ_REPEATED_FIXED_SIZE_PRIMITIVE
311
312template <typename CType, enum WireFormatLite::FieldType DeclaredType>
313bool 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
322template <typename CType, enum WireFormatLite::FieldType DeclaredType>
323inline 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
337template <typename CType, enum WireFormatLite::FieldType DeclaredType>
338bool WireFormatLite::ReadPackedPrimitiveNoInline(io::CodedInputStream* input,
339                                                 RepeatedField<CType>* values) {
340  return ReadPackedPrimitive<CType, DeclaredType>(input, values);
341}
342
343
344inline 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}
356inline 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// We name the template parameter something long and extremely unlikely to occur
372// elsewhere because a *qualified* member access expression designed to avoid
373// virtual dispatch, C++03 [basic.lookup.classref] 3.4.5/4 requires that the
374// name of the qualifying class to be looked up both in the context of the full
375// expression (finding the template parameter) and in the context of the object
376// whose member we are accessing. This could potentially find a nested type
377// within that object. The standard goes on to require these names to refer to
378// the same entity, which this collision would violate. The lack of a safe way
379// to avoid this collision appears to be a defect in the standard, but until it
380// is corrected, we choose the name to avoid accidental collisions.
381template<typename MessageType_WorkAroundCppLookupDefect>
382inline bool WireFormatLite::ReadGroupNoVirtual(
383    int field_number, io::CodedInputStream* input,
384    MessageType_WorkAroundCppLookupDefect* value) {
385  if (!input->IncrementRecursionDepth()) return false;
386  if (!value->
387      MessageType_WorkAroundCppLookupDefect::MergePartialFromCodedStream(input))
388    return false;
389  input->DecrementRecursionDepth();
390  // Make sure the last thing read was an end tag for this group.
391  if (!input->LastTagWas(MakeTag(field_number, WIRETYPE_END_GROUP))) {
392    return false;
393  }
394  return true;
395}
396template<typename MessageType_WorkAroundCppLookupDefect>
397inline bool WireFormatLite::ReadMessageNoVirtual(
398    io::CodedInputStream* input, MessageType_WorkAroundCppLookupDefect* value) {
399  uint32 length;
400  if (!input->ReadVarint32(&length)) return false;
401  if (!input->IncrementRecursionDepth()) return false;
402  io::CodedInputStream::Limit limit = input->PushLimit(length);
403  if (!value->
404      MessageType_WorkAroundCppLookupDefect::MergePartialFromCodedStream(input))
405    return false;
406  // Make sure that parsing stopped when the limit was hit, not at an endgroup
407  // tag.
408  if (!input->ConsumedEntireMessage()) return false;
409  input->PopLimit(limit);
410  input->DecrementRecursionDepth();
411  return true;
412}
413
414// ===================================================================
415
416inline void WireFormatLite::WriteTag(int field_number, WireType type,
417                                     io::CodedOutputStream* output) {
418  output->WriteTag(MakeTag(field_number, type));
419}
420
421inline void WireFormatLite::WriteInt32NoTag(int32 value,
422                                            io::CodedOutputStream* output) {
423  output->WriteVarint32SignExtended(value);
424}
425inline void WireFormatLite::WriteInt64NoTag(int64 value,
426                                            io::CodedOutputStream* output) {
427  output->WriteVarint64(static_cast<uint64>(value));
428}
429inline void WireFormatLite::WriteUInt32NoTag(uint32 value,
430                                             io::CodedOutputStream* output) {
431  output->WriteVarint32(value);
432}
433inline void WireFormatLite::WriteUInt64NoTag(uint64 value,
434                                             io::CodedOutputStream* output) {
435  output->WriteVarint64(value);
436}
437inline void WireFormatLite::WriteSInt32NoTag(int32 value,
438                                             io::CodedOutputStream* output) {
439  output->WriteVarint32(ZigZagEncode32(value));
440}
441inline void WireFormatLite::WriteSInt64NoTag(int64 value,
442                                             io::CodedOutputStream* output) {
443  output->WriteVarint64(ZigZagEncode64(value));
444}
445inline void WireFormatLite::WriteFixed32NoTag(uint32 value,
446                                              io::CodedOutputStream* output) {
447  output->WriteLittleEndian32(value);
448}
449inline void WireFormatLite::WriteFixed64NoTag(uint64 value,
450                                              io::CodedOutputStream* output) {
451  output->WriteLittleEndian64(value);
452}
453inline void WireFormatLite::WriteSFixed32NoTag(int32 value,
454                                               io::CodedOutputStream* output) {
455  output->WriteLittleEndian32(static_cast<uint32>(value));
456}
457inline void WireFormatLite::WriteSFixed64NoTag(int64 value,
458                                               io::CodedOutputStream* output) {
459  output->WriteLittleEndian64(static_cast<uint64>(value));
460}
461inline void WireFormatLite::WriteFloatNoTag(float value,
462                                            io::CodedOutputStream* output) {
463  output->WriteLittleEndian32(EncodeFloat(value));
464}
465inline void WireFormatLite::WriteDoubleNoTag(double value,
466                                             io::CodedOutputStream* output) {
467  output->WriteLittleEndian64(EncodeDouble(value));
468}
469inline void WireFormatLite::WriteBoolNoTag(bool value,
470                                           io::CodedOutputStream* output) {
471  output->WriteVarint32(value ? 1 : 0);
472}
473inline void WireFormatLite::WriteEnumNoTag(int value,
474                                           io::CodedOutputStream* output) {
475  output->WriteVarint32SignExtended(value);
476}
477
478// See comment on ReadGroupNoVirtual to understand the need for this template
479// parameter name.
480template<typename MessageType_WorkAroundCppLookupDefect>
481inline void WireFormatLite::WriteGroupNoVirtual(
482    int field_number, const MessageType_WorkAroundCppLookupDefect& value,
483    io::CodedOutputStream* output) {
484  WriteTag(field_number, WIRETYPE_START_GROUP, output);
485  value.MessageType_WorkAroundCppLookupDefect::SerializeWithCachedSizes(output);
486  WriteTag(field_number, WIRETYPE_END_GROUP, output);
487}
488template<typename MessageType_WorkAroundCppLookupDefect>
489inline void WireFormatLite::WriteMessageNoVirtual(
490    int field_number, const MessageType_WorkAroundCppLookupDefect& value,
491    io::CodedOutputStream* output) {
492  WriteTag(field_number, WIRETYPE_LENGTH_DELIMITED, output);
493  output->WriteVarint32(
494      value.MessageType_WorkAroundCppLookupDefect::GetCachedSize());
495  value.MessageType_WorkAroundCppLookupDefect::SerializeWithCachedSizes(output);
496}
497
498// ===================================================================
499
500inline uint8* WireFormatLite::WriteTagToArray(int field_number,
501                                              WireType type,
502                                              uint8* target) {
503  return io::CodedOutputStream::WriteTagToArray(MakeTag(field_number, type),
504                                                target);
505}
506
507inline uint8* WireFormatLite::WriteInt32NoTagToArray(int32 value,
508                                                     uint8* target) {
509  return io::CodedOutputStream::WriteVarint32SignExtendedToArray(value, target);
510}
511inline uint8* WireFormatLite::WriteInt64NoTagToArray(int64 value,
512                                                     uint8* target) {
513  return io::CodedOutputStream::WriteVarint64ToArray(
514      static_cast<uint64>(value), target);
515}
516inline uint8* WireFormatLite::WriteUInt32NoTagToArray(uint32 value,
517                                                      uint8* target) {
518  return io::CodedOutputStream::WriteVarint32ToArray(value, target);
519}
520inline uint8* WireFormatLite::WriteUInt64NoTagToArray(uint64 value,
521                                                      uint8* target) {
522  return io::CodedOutputStream::WriteVarint64ToArray(value, target);
523}
524inline uint8* WireFormatLite::WriteSInt32NoTagToArray(int32 value,
525                                                      uint8* target) {
526  return io::CodedOutputStream::WriteVarint32ToArray(ZigZagEncode32(value),
527                                                     target);
528}
529inline uint8* WireFormatLite::WriteSInt64NoTagToArray(int64 value,
530                                                      uint8* target) {
531  return io::CodedOutputStream::WriteVarint64ToArray(ZigZagEncode64(value),
532                                                     target);
533}
534inline uint8* WireFormatLite::WriteFixed32NoTagToArray(uint32 value,
535                                                       uint8* target) {
536  return io::CodedOutputStream::WriteLittleEndian32ToArray(value, target);
537}
538inline uint8* WireFormatLite::WriteFixed64NoTagToArray(uint64 value,
539                                                       uint8* target) {
540  return io::CodedOutputStream::WriteLittleEndian64ToArray(value, target);
541}
542inline uint8* WireFormatLite::WriteSFixed32NoTagToArray(int32 value,
543                                                        uint8* target) {
544  return io::CodedOutputStream::WriteLittleEndian32ToArray(
545      static_cast<uint32>(value), target);
546}
547inline uint8* WireFormatLite::WriteSFixed64NoTagToArray(int64 value,
548                                                        uint8* target) {
549  return io::CodedOutputStream::WriteLittleEndian64ToArray(
550      static_cast<uint64>(value), target);
551}
552inline uint8* WireFormatLite::WriteFloatNoTagToArray(float value,
553                                                     uint8* target) {
554  return io::CodedOutputStream::WriteLittleEndian32ToArray(EncodeFloat(value),
555                                                           target);
556}
557inline uint8* WireFormatLite::WriteDoubleNoTagToArray(double value,
558                                                      uint8* target) {
559  return io::CodedOutputStream::WriteLittleEndian64ToArray(EncodeDouble(value),
560                                                           target);
561}
562inline uint8* WireFormatLite::WriteBoolNoTagToArray(bool value,
563                                                    uint8* target) {
564  return io::CodedOutputStream::WriteVarint32ToArray(value ? 1 : 0, target);
565}
566inline uint8* WireFormatLite::WriteEnumNoTagToArray(int value,
567                                                    uint8* target) {
568  return io::CodedOutputStream::WriteVarint32SignExtendedToArray(value, target);
569}
570
571inline uint8* WireFormatLite::WriteInt32ToArray(int field_number,
572                                                int32 value,
573                                                uint8* target) {
574  target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
575  return WriteInt32NoTagToArray(value, target);
576}
577inline uint8* WireFormatLite::WriteInt64ToArray(int field_number,
578                                                int64 value,
579                                                uint8* target) {
580  target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
581  return WriteInt64NoTagToArray(value, target);
582}
583inline uint8* WireFormatLite::WriteUInt32ToArray(int field_number,
584                                                 uint32 value,
585                                                 uint8* target) {
586  target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
587  return WriteUInt32NoTagToArray(value, target);
588}
589inline uint8* WireFormatLite::WriteUInt64ToArray(int field_number,
590                                                 uint64 value,
591                                                 uint8* target) {
592  target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
593  return WriteUInt64NoTagToArray(value, target);
594}
595inline uint8* WireFormatLite::WriteSInt32ToArray(int field_number,
596                                                 int32 value,
597                                                 uint8* target) {
598  target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
599  return WriteSInt32NoTagToArray(value, target);
600}
601inline uint8* WireFormatLite::WriteSInt64ToArray(int field_number,
602                                                 int64 value,
603                                                 uint8* target) {
604  target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
605  return WriteSInt64NoTagToArray(value, target);
606}
607inline uint8* WireFormatLite::WriteFixed32ToArray(int field_number,
608                                                  uint32 value,
609                                                  uint8* target) {
610  target = WriteTagToArray(field_number, WIRETYPE_FIXED32, target);
611  return WriteFixed32NoTagToArray(value, target);
612}
613inline uint8* WireFormatLite::WriteFixed64ToArray(int field_number,
614                                                  uint64 value,
615                                                  uint8* target) {
616  target = WriteTagToArray(field_number, WIRETYPE_FIXED64, target);
617  return WriteFixed64NoTagToArray(value, target);
618}
619inline uint8* WireFormatLite::WriteSFixed32ToArray(int field_number,
620                                                   int32 value,
621                                                   uint8* target) {
622  target = WriteTagToArray(field_number, WIRETYPE_FIXED32, target);
623  return WriteSFixed32NoTagToArray(value, target);
624}
625inline uint8* WireFormatLite::WriteSFixed64ToArray(int field_number,
626                                                   int64 value,
627                                                   uint8* target) {
628  target = WriteTagToArray(field_number, WIRETYPE_FIXED64, target);
629  return WriteSFixed64NoTagToArray(value, target);
630}
631inline uint8* WireFormatLite::WriteFloatToArray(int field_number,
632                                                float value,
633                                                uint8* target) {
634  target = WriteTagToArray(field_number, WIRETYPE_FIXED32, target);
635  return WriteFloatNoTagToArray(value, target);
636}
637inline uint8* WireFormatLite::WriteDoubleToArray(int field_number,
638                                                 double value,
639                                                 uint8* target) {
640  target = WriteTagToArray(field_number, WIRETYPE_FIXED64, target);
641  return WriteDoubleNoTagToArray(value, target);
642}
643inline uint8* WireFormatLite::WriteBoolToArray(int field_number,
644                                               bool value,
645                                               uint8* target) {
646  target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
647  return WriteBoolNoTagToArray(value, target);
648}
649inline uint8* WireFormatLite::WriteEnumToArray(int field_number,
650                                               int value,
651                                               uint8* target) {
652  target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
653  return WriteEnumNoTagToArray(value, target);
654}
655
656inline uint8* WireFormatLite::WriteStringToArray(int field_number,
657                                                 const string& value,
658                                                 uint8* target) {
659  // String is for UTF-8 text only
660  // WARNING:  In wire_format.cc, both strings and bytes are handled by
661  //   WriteString() to avoid code duplication.  If the implementations become
662  //   different, you will need to update that usage.
663  target = WriteTagToArray(field_number, WIRETYPE_LENGTH_DELIMITED, target);
664  target = io::CodedOutputStream::WriteVarint32ToArray(value.size(), target);
665  return io::CodedOutputStream::WriteStringToArray(value, target);
666}
667inline uint8* WireFormatLite::WriteBytesToArray(int field_number,
668                                                const string& value,
669                                                uint8* target) {
670  target = WriteTagToArray(field_number, WIRETYPE_LENGTH_DELIMITED, target);
671  target = io::CodedOutputStream::WriteVarint32ToArray(value.size(), target);
672  return io::CodedOutputStream::WriteStringToArray(value, target);
673}
674
675
676inline uint8* WireFormatLite::WriteGroupToArray(int field_number,
677                                                const MessageLite& value,
678                                                uint8* target) {
679  target = WriteTagToArray(field_number, WIRETYPE_START_GROUP, target);
680  target = value.SerializeWithCachedSizesToArray(target);
681  return WriteTagToArray(field_number, WIRETYPE_END_GROUP, target);
682}
683inline uint8* WireFormatLite::WriteMessageToArray(int field_number,
684                                                  const MessageLite& value,
685                                                  uint8* target) {
686  target = WriteTagToArray(field_number, WIRETYPE_LENGTH_DELIMITED, target);
687  target = io::CodedOutputStream::WriteVarint32ToArray(
688    value.GetCachedSize(), target);
689  return value.SerializeWithCachedSizesToArray(target);
690}
691
692// See comment on ReadGroupNoVirtual to understand the need for this template
693// parameter name.
694template<typename MessageType_WorkAroundCppLookupDefect>
695inline uint8* WireFormatLite::WriteGroupNoVirtualToArray(
696    int field_number, const MessageType_WorkAroundCppLookupDefect& value,
697    uint8* target) {
698  target = WriteTagToArray(field_number, WIRETYPE_START_GROUP, target);
699  target = value.MessageType_WorkAroundCppLookupDefect
700      ::SerializeWithCachedSizesToArray(target);
701  return WriteTagToArray(field_number, WIRETYPE_END_GROUP, target);
702}
703template<typename MessageType_WorkAroundCppLookupDefect>
704inline uint8* WireFormatLite::WriteMessageNoVirtualToArray(
705    int field_number, const MessageType_WorkAroundCppLookupDefect& value,
706    uint8* target) {
707  target = WriteTagToArray(field_number, WIRETYPE_LENGTH_DELIMITED, target);
708  target = io::CodedOutputStream::WriteVarint32ToArray(
709    value.MessageType_WorkAroundCppLookupDefect::GetCachedSize(), target);
710  return value.MessageType_WorkAroundCppLookupDefect
711      ::SerializeWithCachedSizesToArray(target);
712}
713
714// ===================================================================
715
716inline int WireFormatLite::Int32Size(int32 value) {
717  return io::CodedOutputStream::VarintSize32SignExtended(value);
718}
719inline int WireFormatLite::Int64Size(int64 value) {
720  return io::CodedOutputStream::VarintSize64(static_cast<uint64>(value));
721}
722inline int WireFormatLite::UInt32Size(uint32 value) {
723  return io::CodedOutputStream::VarintSize32(value);
724}
725inline int WireFormatLite::UInt64Size(uint64 value) {
726  return io::CodedOutputStream::VarintSize64(value);
727}
728inline int WireFormatLite::SInt32Size(int32 value) {
729  return io::CodedOutputStream::VarintSize32(ZigZagEncode32(value));
730}
731inline int WireFormatLite::SInt64Size(int64 value) {
732  return io::CodedOutputStream::VarintSize64(ZigZagEncode64(value));
733}
734inline int WireFormatLite::EnumSize(int value) {
735  return io::CodedOutputStream::VarintSize32SignExtended(value);
736}
737
738inline int WireFormatLite::StringSize(const string& value) {
739  return io::CodedOutputStream::VarintSize32(value.size()) +
740         value.size();
741}
742inline int WireFormatLite::BytesSize(const string& value) {
743  return io::CodedOutputStream::VarintSize32(value.size()) +
744         value.size();
745}
746
747
748inline int WireFormatLite::GroupSize(const MessageLite& value) {
749  return value.ByteSize();
750}
751inline int WireFormatLite::MessageSize(const MessageLite& value) {
752  int size = value.ByteSize();
753  return io::CodedOutputStream::VarintSize32(size) + size;
754}
755
756// See comment on ReadGroupNoVirtual to understand the need for this template
757// parameter name.
758template<typename MessageType_WorkAroundCppLookupDefect>
759inline int WireFormatLite::GroupSizeNoVirtual(
760    const MessageType_WorkAroundCppLookupDefect& value) {
761  return value.MessageType_WorkAroundCppLookupDefect::ByteSize();
762}
763template<typename MessageType_WorkAroundCppLookupDefect>
764inline int WireFormatLite::MessageSizeNoVirtual(
765    const MessageType_WorkAroundCppLookupDefect& value) {
766  int size = value.MessageType_WorkAroundCppLookupDefect::ByteSize();
767  return io::CodedOutputStream::VarintSize32(size) + size;
768}
769
770}  // namespace internal
771}  // namespace protobuf
772
773}  // namespace google
774#endif  // GOOGLE_PROTOBUF_WIRE_FORMAT_LITE_INL_H__