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

   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/io/coded_stream.h>
  45
  46
  47 namespace google {
  48 namespace protobuf {
  49 namespace internal {
  50
  51 // Implementation details of ReadPrimitive.
  52
  53 template <>
  54 inline bool WireFormatLite::ReadPrimitive<int32, WireFormatLite::TYPE_INT32>(
  55     io::CodedInputStream* input,
  56     int32* value) {
  57   uint32 temp;
  58   if (!input->ReadVarint32(&temp)) return false;
  59   *value = static_cast<int32>(temp);
  60   return true;
  61 }
  62 template <>
  63 inline bool WireFormatLite::ReadPrimitive<int64, WireFormatLite::TYPE_INT64>(
  64     io::CodedInputStream* input,
  65     int64* value) {
  66   uint64 temp;
  67   if (!input->ReadVarint64(&temp)) return false;
  68   *value = static_cast<int64>(temp);
  69   return true;
  70 }
  71 template <>
  72 inline bool WireFormatLite::ReadPrimitive<uint32, WireFormatLite::TYPE_UINT32>(
  73     io::CodedInputStream* input,
  74     uint32* value) {
  75   return input->ReadVarint32(value);
  76 }
  77 template <>
  78 inline bool WireFormatLite::ReadPrimitive<uint64, WireFormatLite::TYPE_UINT64>(
  79     io::CodedInputStream* input,
  80     uint64* value) {
  81   return input->ReadVarint64(value);
  82 }
  83 template <>
  84 inline bool WireFormatLite::ReadPrimitive<int32, WireFormatLite::TYPE_SINT32>(
  85     io::CodedInputStream* input,
  86     int32* value) {
  87   uint32 temp;
  88   if (!input->ReadVarint32(&temp)) return false;
  89   *value = ZigZagDecode32(temp);
  90   return true;
  91 }
  92 template <>
  93 inline bool WireFormatLite::ReadPrimitive<int64, WireFormatLite::TYPE_SINT64>(
  94     io::CodedInputStream* input,
  95     int64* value) {
  96   uint64 temp;
  97   if (!input->ReadVarint64(&temp)) return false;
  98   *value = ZigZagDecode64(temp);
  99   return true;
 100 }
 101 template <>
 102 inline bool WireFormatLite::ReadPrimitive<uint32, WireFormatLite::TYPE_FIXED32>(
 103     io::CodedInputStream* input,
 104     uint32* value) {
 105   return input->ReadLittleEndian32(value);
 106 }
 107 template <>
 108 inline bool WireFormatLite::ReadPrimitive<uint64, WireFormatLite::TYPE_FIXED64>(
 109     io::CodedInputStream* input,
 110     uint64* value) {
 111   return input->ReadLittleEndian64(value);
 112 }
 113 template <>
 114 inline bool WireFormatLite::ReadPrimitive<int32, WireFormatLite::TYPE_SFIXED32>(
 115     io::CodedInputStream* input,
 116     int32* value) {
 117   uint32 temp;
 118   if (!input->ReadLittleEndian32(&temp)) return false;
 119   *value = static_cast<int32>(temp);
 120   return true;
 121 }
 122 template <>
 123 inline bool WireFormatLite::ReadPrimitive<int64, WireFormatLite::TYPE_SFIXED64>(
 124     io::CodedInputStream* input,
 125     int64* value) {
 126   uint64 temp;
 127   if (!input->ReadLittleEndian64(&temp)) return false;
 128   *value = static_cast<int64>(temp);
 129   return true;
 130 }
 131 template <>
 132 inline bool WireFormatLite::ReadPrimitive<float, WireFormatLite::TYPE_FLOAT>(
 133     io::CodedInputStream* input,
 134     float* value) {
 135   uint32 temp;
 136   if (!input->ReadLittleEndian32(&temp)) return false;
 137   *value = DecodeFloat(temp);
 138   return true;
 139 }
 140 template <>
 141 inline bool WireFormatLite::ReadPrimitive<double, WireFormatLite::TYPE_DOUBLE>(
 142     io::CodedInputStream* input,
 143     double* value) {
 144   uint64 temp;
 145   if (!input->ReadLittleEndian64(&temp)) return false;
 146   *value = DecodeDouble(temp);
 147   return true;
 148 }
 149 template <>
 150 inline bool WireFormatLite::ReadPrimitive<bool, WireFormatLite::TYPE_BOOL>(
 151     io::CodedInputStream* input,
 152     bool* value) {
 153   uint32 temp;
 154   if (!input->ReadVarint32(&temp)) return false;
 155   *value = temp != 0;
 156   return true;
 157 }
 158 template <>
 159 inline bool WireFormatLite::ReadPrimitive<int, WireFormatLite::TYPE_ENUM>(
 160     io::CodedInputStream* input,
 161     int* value) {
 162   uint32 temp;
 163   if (!input->ReadVarint32(&temp)) return false;
 164   *value = static_cast<int>(temp);
 165   return true;
 166 }
 167
 168 template <>
 169 inline const uint8* WireFormatLite::ReadPrimitiveFromArray<
 170   uint32, WireFormatLite::TYPE_FIXED32>(
 171     const uint8* buffer,
 172     uint32* value) {
 173   return io::CodedInputStream::ReadLittleEndian32FromArray(buffer, value);
 174 }
 175 template <>
 176 inline const uint8* WireFormatLite::ReadPrimitiveFromArray<
 177   uint64, WireFormatLite::TYPE_FIXED64>(
 178     const uint8* buffer,
 179     uint64* value) {
 180   return io::CodedInputStream::ReadLittleEndian64FromArray(buffer, value);
 181 }
 182 template <>
 183 inline const uint8* WireFormatLite::ReadPrimitiveFromArray<
 184   int32, WireFormatLite::TYPE_SFIXED32>(
 185     const uint8* buffer,
 186     int32* value) {
 187   uint32 temp;
 188   buffer = io::CodedInputStream::ReadLittleEndian32FromArray(buffer, &temp);
 189   *value = static_cast<int32>(temp);
 190   return buffer;
 191 }
 192 template <>
 193 inline const uint8* WireFormatLite::ReadPrimitiveFromArray<
 194   int64, WireFormatLite::TYPE_SFIXED64>(
 195     const uint8* buffer,
 196     int64* value) {
 197   uint64 temp;
 198   buffer = io::CodedInputStream::ReadLittleEndian64FromArray(buffer, &temp);
 199   *value = static_cast<int64>(temp);
 200   return buffer;
 201 }
 202 template <>
 203 inline const uint8* WireFormatLite::ReadPrimitiveFromArray<
 204   float, WireFormatLite::TYPE_FLOAT>(
 205     const uint8* buffer,
 206     float* value) {
 207   uint32 temp;
 208   buffer = io::CodedInputStream::ReadLittleEndian32FromArray(buffer, &temp);
 209   *value = DecodeFloat(temp);
 210   return buffer;
 211 }
 212 template <>
 213 inline const uint8* WireFormatLite::ReadPrimitiveFromArray<
 214   double, WireFormatLite::TYPE_DOUBLE>(
 215     const uint8* buffer,
 216     double* value) {
 217   uint64 temp;
 218   buffer = io::CodedInputStream::ReadLittleEndian64FromArray(buffer, &temp);
 219   *value = DecodeDouble(temp);
 220   return buffer;
 221 }
 222
 223 template <typename CType, enum WireFormatLite::FieldType DeclaredType>
 224 inline bool WireFormatLite::ReadRepeatedPrimitive(int, // tag_size, unused.
 225                                                uint32 tag,
 226                                                io::CodedInputStream* input,
 227                                                RepeatedField<CType>* values) {
 228   CType value;
 229   if (!ReadPrimitive<CType, DeclaredType>(input, &value)) return false;
 230   values->Add(value);
 231   int elements_already_reserved = values->Capacity() - values->size();
 232   while (elements_already_reserved > 0 && input->ExpectTag(tag)) {
 233     if (!ReadPrimitive<CType, DeclaredType>(input, &value)) return false;
 234     values->AddAlreadyReserved(value);
 235     elements_already_reserved--;
 236   }
 237   return true;
 238 }
 239
 240 template <typename CType, enum WireFormatLite::FieldType DeclaredType>
 241 inline bool WireFormatLite::ReadRepeatedFixedSizePrimitive(
 242     int tag_size,
 243     uint32 tag,
 244     io::CodedInputStream* input,
 245     RepeatedField<CType>* values) {
 246   GOOGLE_DCHECK_EQ(UInt32Size(tag), tag_size);
 247   CType value;
 248   if (!ReadPrimitive<CType, DeclaredType>(input, &value))
 249     return false;
 250   values->Add(value);
 251
 252   // For fixed size values, repeated values can be read more quickly by
 253   // reading directly from a raw array.
 254   //
 255   // We can get a tight loop by only reading as many elements as can be
 256   // added to the RepeatedField without having to do any resizing. Additionally,
 257   // we only try to read as many elements as are available from the current
 258   // buffer space. Doing so avoids having to perform boundary checks when
 259   // reading the value: the maximum number of elements that can be read is
 260   // known outside of the loop.
 261   const void* void_pointer;
 262   int size;
 263   input->GetDirectBufferPointerInline(&void_pointer, &size);
 264   if (size > 0) {
 265     const uint8* buffer = reinterpret_cast<const uint8*>(void_pointer);
 266     // The number of bytes each type occupies on the wire.
 267     const int per_value_size = tag_size + sizeof(value);
 268
 269     int elements_available = min(values->Capacity() - values->size(),
 270                                  size / per_value_size);
 271     int num_read = 0;
 272     while (num_read < elements_available &&
 273            (buffer = io::CodedInputStream::ExpectTagFromArray(
 274                buffer, tag)) != NULL) {
 275       buffer = ReadPrimitiveFromArray<CType, DeclaredType>(buffer, &value);
 276       values->AddAlreadyReserved(value);
 277       ++num_read;
 278     }
 279     const int read_bytes = num_read * per_value_size;
 280     if (read_bytes > 0) {
 281       input->Skip(read_bytes);
 282     }
 283   }
 284   return true;
 285 }
 286
 287 // Specializations of ReadRepeatedPrimitive for the fixed size types, which use
 288 // the optimized code path.
 289 #define READ_REPEATED_FIXED_SIZE_PRIMITIVE(CPPTYPE, DECLARED_TYPE)             \
 290 template <>                                                                    \
 291 inline bool WireFormatLite::ReadRepeatedPrimitive<                             \
 292   CPPTYPE, WireFormatLite::DECLARED_TYPE>(                                     \
 293     int tag_size,                                                              \
 294     uint32 tag,                                                                \
 295     io::CodedInputStream* input,                                               \
 296     RepeatedField<CPPTYPE>* values) {                                          \
 297   return ReadRepeatedFixedSizePrimitive<                                       \
 298     CPPTYPE, WireFormatLite::DECLARED_TYPE>(                                   \
 299       tag_size, tag, input, values);                                           \
 300 }
 301
 302 READ_REPEATED_FIXED_SIZE_PRIMITIVE(uint32, TYPE_FIXED32)
 303 READ_REPEATED_FIXED_SIZE_PRIMITIVE(uint64, TYPE_FIXED64)
 304 READ_REPEATED_FIXED_SIZE_PRIMITIVE(int32, TYPE_SFIXED32)
 305 READ_REPEATED_FIXED_SIZE_PRIMITIVE(int64, TYPE_SFIXED64)
 306 READ_REPEATED_FIXED_SIZE_PRIMITIVE(float, TYPE_FLOAT)
 307 READ_REPEATED_FIXED_SIZE_PRIMITIVE(double, TYPE_DOUBLE)
 308
 309 #undef READ_REPEATED_FIXED_SIZE_PRIMITIVE
 310
 311 template <typename CType, enum WireFormatLite::FieldType DeclaredType>
 312 bool WireFormatLite::ReadRepeatedPrimitiveNoInline(
 313     int tag_size,
 314     uint32 tag,
 315     io::CodedInputStream* input,
 316     RepeatedField<CType>* value) {
 317   return ReadRepeatedPrimitive<CType, DeclaredType>(
 318       tag_size, tag, input, value);
 319 }
 320
 321 template <typename CType, enum WireFormatLite::FieldType DeclaredType>
 322 inline bool WireFormatLite::ReadPackedPrimitive(io::CodedInputStream* input,
 323                                                 RepeatedField<CType>* values) {
 324   uint32 length;
 325   if (!input->ReadVarint32(&length)) return false;
 326   io::CodedInputStream::Limit limit = input->PushLimit(length);
 327   while (input->BytesUntilLimit() > 0) {
 328     CType value;
 329     if (!ReadPrimitive<CType, DeclaredType>(input, &value)) return false;
 330     values->Add(value);
 331   }
 332   input->PopLimit(limit);
 333   return true;
 334 }
 335
 336 template <typename CType, enum WireFormatLite::FieldType DeclaredType>
 337 bool WireFormatLite::ReadPackedPrimitiveNoInline(io::CodedInputStream* input,
 338                                                  RepeatedField<CType>* values) {
 339   return ReadPackedPrimitive<CType, DeclaredType>(input, values);
 340 }
 341
 342
 343 inline bool WireFormatLite::ReadGroup(int field_number,
 344                                       io::CodedInputStream* input,
 345                                       MessageLite* value) {
 346   if (!input->IncrementRecursionDepth()) return false;
 347   if (!value->MergePartialFromCodedStream(input)) return false;
 348   input->DecrementRecursionDepth();
 349   // Make sure the last thing read was an end tag for this group.
 350   if (!input->LastTagWas(MakeTag(field_number, WIRETYPE_END_GROUP))) {
 351     return false;
 352   }
 353   return true;
 354 }
 355 inline bool WireFormatLite::ReadMessage(io::CodedInputStream* input,
 356                                         MessageLite* value) {
 357   uint32 length;
 358   if (!input->ReadVarint32(&length)) return false;
 359   if (!input->IncrementRecursionDepth()) return false;
 360   io::CodedInputStream::Limit limit = input->PushLimit(length);
 361   if (!value->MergePartialFromCodedStream(input)) return false;
 362   // Make sure that parsing stopped when the limit was hit, not at an endgroup
 363   // tag.
 364   if (!input->ConsumedEntireMessage()) return false;
 365   input->PopLimit(limit);
 366   input->DecrementRecursionDepth();
 367   return true;
 368 }
 369
 370 // We name the template parameter something long and extremely unlikely to occur
 371 // elsewhere because a *qualified* member access expression designed to avoid
 372 // virtual dispatch, C++03 [basic.lookup.classref] 3.4.5/4 requires that the
 373 // name of the qualifying class to be looked up both in the context of the full
 374 // expression (finding the template parameter) and in the context of the object
 375 // whose member we are accessing. This could potentially find a nested type
 376 // within that object. The standard goes on to require these names to refer to
 377 // the same entity, which this collision would violate. The lack of a safe way
 378 // to avoid this collision appears to be a defect in the standard, but until it
 379 // is corrected, we choose the name to avoid accidental collisions.
 380 template<typename MessageType_WorkAroundCppLookupDefect>
 381 inline bool WireFormatLite::ReadGroupNoVirtual(
 382     int field_number, io::CodedInputStream* input,
 383     MessageType_WorkAroundCppLookupDefect* value) {
 384   if (!input->IncrementRecursionDepth()) return false;
 385   if (!value->
 386       MessageType_WorkAroundCppLookupDefect::MergePartialFromCodedStream(input))
 387     return false;
 388   input->DecrementRecursionDepth();
 389   // Make sure the last thing read was an end tag for this group.
 390   if (!input->LastTagWas(MakeTag(field_number, WIRETYPE_END_GROUP))) {
 391     return false;
 392   }
 393   return true;
 394 }
 395 template<typename MessageType_WorkAroundCppLookupDefect>
 396 inline bool WireFormatLite::ReadMessageNoVirtual(
 397     io::CodedInputStream* input, MessageType_WorkAroundCppLookupDefect* value) {
 398   uint32 length;
 399   if (!input->ReadVarint32(&length)) return false;
 400   if (!input->IncrementRecursionDepth()) return false;
 401   io::CodedInputStream::Limit limit = input->PushLimit(length);
 402   if (!value->
 403       MessageType_WorkAroundCppLookupDefect::MergePartialFromCodedStream(input))
 404     return false;
 405   // Make sure that parsing stopped when the limit was hit, not at an endgroup
 406   // tag.
 407   if (!input->ConsumedEntireMessage()) return false;
 408   input->PopLimit(limit);
 409   input->DecrementRecursionDepth();
 410   return true;
 411 }
 412
 413 // ===================================================================
 414
 415 inline void WireFormatLite::WriteTag(int field_number, WireType type,
 416                                      io::CodedOutputStream* output) {
 417   output->WriteTag(MakeTag(field_number, type));
 418 }
 419
 420 inline void WireFormatLite::WriteInt32NoTag(int32 value,
 421                                             io::CodedOutputStream* output) {
 422   output->WriteVarint32SignExtended(value);
 423 }
 424 inline void WireFormatLite::WriteInt64NoTag(int64 value,
 425                                             io::CodedOutputStream* output) {
 426   output->WriteVarint64(static_cast<uint64>(value));
 427 }
 428 inline void WireFormatLite::WriteUInt32NoTag(uint32 value,
 429                                              io::CodedOutputStream* output) {
 430   output->WriteVarint32(value);
 431 }
 432 inline void WireFormatLite::WriteUInt64NoTag(uint64 value,
 433                                              io::CodedOutputStream* output) {
 434   output->WriteVarint64(value);
 435 }
 436 inline void WireFormatLite::WriteSInt32NoTag(int32 value,
 437                                              io::CodedOutputStream* output) {
 438   output->WriteVarint32(ZigZagEncode32(value));
 439 }
 440 inline void WireFormatLite::WriteSInt64NoTag(int64 value,
 441                                              io::CodedOutputStream* output) {
 442   output->WriteVarint64(ZigZagEncode64(value));
 443 }
 444 inline void WireFormatLite::WriteFixed32NoTag(uint32 value,
 445                                               io::CodedOutputStream* output) {
 446   output->WriteLittleEndian32(value);
 447 }
 448 inline void WireFormatLite::WriteFixed64NoTag(uint64 value,
 449                                               io::CodedOutputStream* output) {
 450   output->WriteLittleEndian64(value);
 451 }
 452 inline void WireFormatLite::WriteSFixed32NoTag(int32 value,
 453                                                io::CodedOutputStream* output) {
 454   output->WriteLittleEndian32(static_cast<uint32>(value));
 455 }
 456 inline void WireFormatLite::WriteSFixed64NoTag(int64 value,
 457                                                io::CodedOutputStream* output) {
 458   output->WriteLittleEndian64(static_cast<uint64>(value));
 459 }
 460 inline void WireFormatLite::WriteFloatNoTag(float value,
 461                                             io::CodedOutputStream* output) {
 462   output->WriteLittleEndian32(EncodeFloat(value));
 463 }
 464 inline void WireFormatLite::WriteDoubleNoTag(double value,
 465                                              io::CodedOutputStream* output) {
 466   output->WriteLittleEndian64(EncodeDouble(value));
 467 }
 468 inline void WireFormatLite::WriteBoolNoTag(bool value,
 469                                            io::CodedOutputStream* output) {
 470   output->WriteVarint32(value ? 1 : 0);
 471 }
 472 inline void WireFormatLite::WriteEnumNoTag(int value,
 473                                            io::CodedOutputStream* output) {
 474   output->WriteVarint32SignExtended(value);
 475 }
 476
 477 // See comment on ReadGroupNoVirtual to understand the need for this template
 478 // parameter name.
 479 template<typename MessageType_WorkAroundCppLookupDefect>
 480 inline void WireFormatLite::WriteGroupNoVirtual(
 481     int field_number, const MessageType_WorkAroundCppLookupDefect& value,
 482     io::CodedOutputStream* output) {
 483   WriteTag(field_number, WIRETYPE_START_GROUP, output);
 484   value.MessageType_WorkAroundCppLookupDefect::SerializeWithCachedSizes(output);
 485   WriteTag(field_number, WIRETYPE_END_GROUP, output);
 486 }
 487 template<typename MessageType_WorkAroundCppLookupDefect>
 488 inline void WireFormatLite::WriteMessageNoVirtual(
 489     int field_number, const MessageType_WorkAroundCppLookupDefect& value,
 490     io::CodedOutputStream* output) {
 491   WriteTag(field_number, WIRETYPE_LENGTH_DELIMITED, output);
 492   output->WriteVarint32(
 493       value.MessageType_WorkAroundCppLookupDefect::GetCachedSize());
 494   value.MessageType_WorkAroundCppLookupDefect::SerializeWithCachedSizes(output);
 495 }
 496
 497 // ===================================================================
 498
 499 inline uint8* WireFormatLite::WriteTagToArray(int field_number,
 500                                               WireType type,
 501                                               uint8* target) {
 502   return io::CodedOutputStream::WriteTagToArray(MakeTag(field_number, type),
 503                                                 target);
 504 }
 505
 506 inline uint8* WireFormatLite::WriteInt32NoTagToArray(int32 value,
 507                                                      uint8* target) {
 508   return io::CodedOutputStream::WriteVarint32SignExtendedToArray(value, target);
 509 }
 510 inline uint8* WireFormatLite::WriteInt64NoTagToArray(int64 value,
 511                                                      uint8* target) {
 512   return io::CodedOutputStream::WriteVarint64ToArray(
 513       static_cast<uint64>(value), target);
 514 }
 515 inline uint8* WireFormatLite::WriteUInt32NoTagToArray(uint32 value,
 516                                                       uint8* target) {
 517   return io::CodedOutputStream::WriteVarint32ToArray(value, target);
 518 }
 519 inline uint8* WireFormatLite::WriteUInt64NoTagToArray(uint64 value,
 520                                                       uint8* target) {
 521   return io::CodedOutputStream::WriteVarint64ToArray(value, target);
 522 }
 523 inline uint8* WireFormatLite::WriteSInt32NoTagToArray(int32 value,
 524                                                       uint8* target) {
 525   return io::CodedOutputStream::WriteVarint32ToArray(ZigZagEncode32(value),
 526                                                      target);
 527 }
 528 inline uint8* WireFormatLite::WriteSInt64NoTagToArray(int64 value,
 529                                                       uint8* target) {
 530   return io::CodedOutputStream::WriteVarint64ToArray(ZigZagEncode64(value),
 531                                                      target);
 532 }
 533 inline uint8* WireFormatLite::WriteFixed32NoTagToArray(uint32 value,
 534                                                        uint8* target) {
 535   return io::CodedOutputStream::WriteLittleEndian32ToArray(value, target);
 536 }
 537 inline uint8* WireFormatLite::WriteFixed64NoTagToArray(uint64 value,
 538                                                        uint8* target) {
 539   return io::CodedOutputStream::WriteLittleEndian64ToArray(value, target);
 540 }
 541 inline uint8* WireFormatLite::WriteSFixed32NoTagToArray(int32 value,
 542                                                         uint8* target) {
 543   return io::CodedOutputStream::WriteLittleEndian32ToArray(
 544       static_cast<uint32>(value), target);
 545 }
 546 inline uint8* WireFormatLite::WriteSFixed64NoTagToArray(int64 value,
 547                                                         uint8* target) {
 548   return io::CodedOutputStream::WriteLittleEndian64ToArray(
 549       static_cast<uint64>(value), target);
 550 }
 551 inline uint8* WireFormatLite::WriteFloatNoTagToArray(float value,
 552                                                      uint8* target) {
 553   return io::CodedOutputStream::WriteLittleEndian32ToArray(EncodeFloat(value),
 554                                                            target);
 555 }
 556 inline uint8* WireFormatLite::WriteDoubleNoTagToArray(double value,
 557                                                       uint8* target) {
 558   return io::CodedOutputStream::WriteLittleEndian64ToArray(EncodeDouble(value),
 559                                                            target);
 560 }
 561 inline uint8* WireFormatLite::WriteBoolNoTagToArray(bool value,
 562                                                     uint8* target) {
 563   return io::CodedOutputStream::WriteVarint32ToArray(value ? 1 : 0, target);
 564 }
 565 inline uint8* WireFormatLite::WriteEnumNoTagToArray(int value,
 566                                                     uint8* target) {
 567   return io::CodedOutputStream::WriteVarint32SignExtendedToArray(value, target);
 568 }
 569
 570 inline uint8* WireFormatLite::WriteInt32ToArray(int field_number,
 571                                                 int32 value,
 572                                                 uint8* target) {
 573   target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
 574   return WriteInt32NoTagToArray(value, target);
 575 }
 576 inline uint8* WireFormatLite::WriteInt64ToArray(int field_number,
 577                                                 int64 value,
 578                                                 uint8* target) {
 579   target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
 580   return WriteInt64NoTagToArray(value, target);
 581 }
 582 inline uint8* WireFormatLite::WriteUInt32ToArray(int field_number,
 583                                                  uint32 value,
 584                                                  uint8* target) {
 585   target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
 586   return WriteUInt32NoTagToArray(value, target);
 587 }
 588 inline uint8* WireFormatLite::WriteUInt64ToArray(int field_number,
 589                                                  uint64 value,
 590                                                  uint8* target) {
 591   target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
 592   return WriteUInt64NoTagToArray(value, target);
 593 }
 594 inline uint8* WireFormatLite::WriteSInt32ToArray(int field_number,
 595                                                  int32 value,
 596                                                  uint8* target) {
 597   target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
 598   return WriteSInt32NoTagToArray(value, target);
 599 }
 600 inline uint8* WireFormatLite::WriteSInt64ToArray(int field_number,
 601                                                  int64 value,
 602                                                  uint8* target) {
 603   target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
 604   return WriteSInt64NoTagToArray(value, target);
 605 }
 606 inline uint8* WireFormatLite::WriteFixed32ToArray(int field_number,
 607                                                   uint32 value,
 608                                                   uint8* target) {
 609   target = WriteTagToArray(field_number, WIRETYPE_FIXED32, target);
 610   return WriteFixed32NoTagToArray(value, target);
 611 }
 612 inline uint8* WireFormatLite::WriteFixed64ToArray(int field_number,
 613                                                   uint64 value,
 614                                                   uint8* target) {
 615   target = WriteTagToArray(field_number, WIRETYPE_FIXED64, target);
 616   return WriteFixed64NoTagToArray(value, target);
 617 }
 618 inline uint8* WireFormatLite::WriteSFixed32ToArray(int field_number,
 619                                                    int32 value,
 620                                                    uint8* target) {
 621   target = WriteTagToArray(field_number, WIRETYPE_FIXED32, target);
 622   return WriteSFixed32NoTagToArray(value, target);
 623 }
 624 inline uint8* WireFormatLite::WriteSFixed64ToArray(int field_number,
 625                                                    int64 value,
 626                                                    uint8* target) {
 627   target = WriteTagToArray(field_number, WIRETYPE_FIXED64, target);
 628   return WriteSFixed64NoTagToArray(value, target);
 629 }
 630 inline uint8* WireFormatLite::WriteFloatToArray(int field_number,
 631                                                 float value,
 632                                                 uint8* target) {
 633   target = WriteTagToArray(field_number, WIRETYPE_FIXED32, target);
 634   return WriteFloatNoTagToArray(value, target);
 635 }
 636 inline uint8* WireFormatLite::WriteDoubleToArray(int field_number,
 637                                                  double value,
 638                                                  uint8* target) {
 639   target = WriteTagToArray(field_number, WIRETYPE_FIXED64, target);
 640   return WriteDoubleNoTagToArray(value, target);
 641 }
 642 inline uint8* WireFormatLite::WriteBoolToArray(int field_number,
 643                                                bool value,
 644                                                uint8* target) {
 645   target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
 646   return WriteBoolNoTagToArray(value, target);
 647 }
 648 inline uint8* WireFormatLite::WriteEnumToArray(int field_number,
 649                                                int value,
 650                                                uint8* target) {
 651   target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
 652   return WriteEnumNoTagToArray(value, target);
 653 }
 654
 655 inline uint8* WireFormatLite::WriteStringToArray(int field_number,
 656                                                  const string& value,
 657                                                  uint8* target) {
 658   // String is for UTF-8 text only
 659   // WARNING:  In wire_format.cc, both strings and bytes are handled by
 660   //   WriteString() to avoid code duplication.  If the implementations become
 661   //   different, you will need to update that usage.
 662   target = WriteTagToArray(field_number, WIRETYPE_LENGTH_DELIMITED, target);
 663   target = io::CodedOutputStream::WriteVarint32ToArray(value.size(), target);
 664   return io::CodedOutputStream::WriteStringToArray(value, target);
 665 }
 666 inline uint8* WireFormatLite::WriteBytesToArray(int field_number,
 667                                                 const string& value,
 668                                                 uint8* target) {
 669   target = WriteTagToArray(field_number, WIRETYPE_LENGTH_DELIMITED, target);
 670   target = io::CodedOutputStream::WriteVarint32ToArray(value.size(), target);
 671   return io::CodedOutputStream::WriteStringToArray(value, target);
 672 }
 673
 674
 675 inline uint8* WireFormatLite::WriteGroupToArray(int field_number,
 676                                                 const MessageLite& value,
 677                                                 uint8* target) {
 678   target = WriteTagToArray(field_number, WIRETYPE_START_GROUP, target);
 679   target = value.SerializeWithCachedSizesToArray(target);
 680   return WriteTagToArray(field_number, WIRETYPE_END_GROUP, target);
 681 }
 682 inline uint8* WireFormatLite::WriteMessageToArray(int field_number,
 683                                                   const MessageLite& value,
 684                                                   uint8* target) {
 685   target = WriteTagToArray(field_number, WIRETYPE_LENGTH_DELIMITED, target);
 686   target = io::CodedOutputStream::WriteVarint32ToArray(
 687     value.GetCachedSize(), target);
 688   return value.SerializeWithCachedSizesToArray(target);
 689 }
 690
 691 // See comment on ReadGroupNoVirtual to understand the need for this template
 692 // parameter name.
 693 template<typename MessageType_WorkAroundCppLookupDefect>
 694 inline uint8* WireFormatLite::WriteGroupNoVirtualToArray(
 695     int field_number, const MessageType_WorkAroundCppLookupDefect& value,
 696     uint8* target) {
 697   target = WriteTagToArray(field_number, WIRETYPE_START_GROUP, target);
 698   target = value.MessageType_WorkAroundCppLookupDefect
 699       ::SerializeWithCachedSizesToArray(target);
 700   return WriteTagToArray(field_number, WIRETYPE_END_GROUP, target);
 701 }
 702 template<typename MessageType_WorkAroundCppLookupDefect>
 703 inline uint8* WireFormatLite::WriteMessageNoVirtualToArray(
 704     int field_number, const MessageType_WorkAroundCppLookupDefect& value,
 705     uint8* target) {
 706   target = WriteTagToArray(field_number, WIRETYPE_LENGTH_DELIMITED, target);
 707   target = io::CodedOutputStream::WriteVarint32ToArray(
 708     value.MessageType_WorkAroundCppLookupDefect::GetCachedSize(), target);
 709   return value.MessageType_WorkAroundCppLookupDefect
 710       ::SerializeWithCachedSizesToArray(target);
 711 }
 712
 713 // ===================================================================
 714
 715 inline int WireFormatLite::Int32Size(int32 value) {
 716   return io::CodedOutputStream::VarintSize32SignExtended(value);
 717 }
 718 inline int WireFormatLite::Int64Size(int64 value) {
 719   return io::CodedOutputStream::VarintSize64(static_cast<uint64>(value));
 720 }
 721 inline int WireFormatLite::UInt32Size(uint32 value) {
 722   return io::CodedOutputStream::VarintSize32(value);
 723 }
 724 inline int WireFormatLite::UInt64Size(uint64 value) {
 725   return io::CodedOutputStream::VarintSize64(value);
 726 }
 727 inline int WireFormatLite::SInt32Size(int32 value) {
 728   return io::CodedOutputStream::VarintSize32(ZigZagEncode32(value));
 729 }
 730 inline int WireFormatLite::SInt64Size(int64 value) {
 731   return io::CodedOutputStream::VarintSize64(ZigZagEncode64(value));
 732 }
 733 inline int WireFormatLite::EnumSize(int value) {
 734   return io::CodedOutputStream::VarintSize32SignExtended(value);
 735 }
 736
 737 inline int WireFormatLite::StringSize(const string& value) {
 738   return io::CodedOutputStream::VarintSize32(value.size()) +
 739          value.size();
 740 }
 741 inline int WireFormatLite::BytesSize(const string& value) {
 742   return io::CodedOutputStream::VarintSize32(value.size()) +
 743          value.size();
 744 }
 745
 746
 747 inline int WireFormatLite::GroupSize(const MessageLite& value) {
 748   return value.ByteSize();
 749 }
 750 inline int WireFormatLite::MessageSize(const MessageLite& value) {
 751   return LengthDelimitedSize(value.ByteSize());
 752 }
 753
 754 // See comment on ReadGroupNoVirtual to understand the need for this template
 755 // parameter name.
 756 template<typename MessageType_WorkAroundCppLookupDefect>
 757 inline int WireFormatLite::GroupSizeNoVirtual(
 758     const MessageType_WorkAroundCppLookupDefect& value) {
 759   return value.MessageType_WorkAroundCppLookupDefect::ByteSize();
 760 }
 761 template<typename MessageType_WorkAroundCppLookupDefect>
 762 inline int WireFormatLite::MessageSizeNoVirtual(
 763     const MessageType_WorkAroundCppLookupDefect& value) {
 764   return LengthDelimitedSize(
 765       value.MessageType_WorkAroundCppLookupDefect::ByteSize());
 766 }
 767
 768 inline int WireFormatLite::LengthDelimitedSize(int length) {
 769   return io::CodedOutputStream::VarintSize32(length) + length;
 770 }
 771
 772 }  // namespace internal
 773 }  // namespace protobuf
 774
 775 }  // namespace google
 776 #endif  // GOOGLE_PROTOBUF_WIRE_FORMAT_LITE_INL_H__