Home | History | Annotate | Download | only in protobuf 
      1 // Protocol Buffers - Google's data interchange format
      2 // Copyright 2008 Google Inc.  All rights reserved.
      3 // https://developers.google.com/protocol-buffers/
      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 (at) google.com (Kenton Varda)
     32 //         atenasio (at) google.com (Chris Atenasio) (ZigZag transform)
     33 //         wink (at) google.com (Wink Saville) (refactored from wire_format.h)
     34 //  Based on original Protocol Buffers design by
     35 //  Sanjay Ghemawat, Jeff Dean, and others.
     36 //
     37 // This header is logically internal, but is made public because it is used
     38 // from protocol-compiler-generated code, which may reside in other components.
     39 
     40 #ifndef GOOGLE_PROTOBUF_WIRE_FORMAT_LITE_H__
     41 #define GOOGLE_PROTOBUF_WIRE_FORMAT_LITE_H__
     42 
     43 #include <string>
     44 #include <google/protobuf/stubs/common.h>
     45 #include <google/protobuf/message_lite.h>
     46 #include <google/protobuf/io/coded_stream.h>  // for CodedOutputStream::Varint32Size
     47 
     48 namespace google {
     49 
     50 namespace protobuf {
     51   template <typename T> class RepeatedField;  // repeated_field.h
     52 }
     53 
     54 namespace protobuf {
     55 namespace internal {
     56 
     57 class StringPieceField;
     58 
     59 // This class is for internal use by the protocol buffer library and by
     60 // protocol-complier-generated message classes.  It must not be called
     61 // directly by clients.
     62 //
     63 // This class contains helpers for implementing the binary protocol buffer
     64 // wire format without the need for reflection. Use WireFormat when using
     65 // reflection.
     66 //
     67 // This class is really a namespace that contains only static methods.
     68 class LIBPROTOBUF_EXPORT WireFormatLite {
     69  public:
     70 
     71   // -----------------------------------------------------------------
     72   // Helper constants and functions related to the format.  These are
     73   // mostly meant for internal and generated code to use.
     74 
     75   // The wire format is composed of a sequence of tag/value pairs, each
     76   // of which contains the value of one field (or one element of a repeated
     77   // field).  Each tag is encoded as a varint.  The lower bits of the tag
     78   // identify its wire type, which specifies the format of the data to follow.
     79   // The rest of the bits contain the field number.  Each type of field (as
     80   // declared by FieldDescriptor::Type, in descriptor.h) maps to one of
     81   // these wire types.  Immediately following each tag is the field's value,
     82   // encoded in the format specified by the wire type.  Because the tag
     83   // identifies the encoding of this data, it is possible to skip
     84   // unrecognized fields for forwards compatibility.
     85 
     86   enum WireType {
     87     WIRETYPE_VARINT           = 0,
     88     WIRETYPE_FIXED64          = 1,
     89     WIRETYPE_LENGTH_DELIMITED = 2,
     90     WIRETYPE_START_GROUP      = 3,
     91     WIRETYPE_END_GROUP        = 4,
     92     WIRETYPE_FIXED32          = 5,
     93   };
     94 
     95   // Lite alternative to FieldDescriptor::Type.  Must be kept in sync.
     96   enum FieldType {
     97     TYPE_DOUBLE         = 1,
     98     TYPE_FLOAT          = 2,
     99     TYPE_INT64          = 3,
    100     TYPE_UINT64         = 4,
    101     TYPE_INT32          = 5,
    102     TYPE_FIXED64        = 6,
    103     TYPE_FIXED32        = 7,
    104     TYPE_BOOL           = 8,
    105     TYPE_STRING         = 9,
    106     TYPE_GROUP          = 10,
    107     TYPE_MESSAGE        = 11,
    108     TYPE_BYTES          = 12,
    109     TYPE_UINT32         = 13,
    110     TYPE_ENUM           = 14,
    111     TYPE_SFIXED32       = 15,
    112     TYPE_SFIXED64       = 16,
    113     TYPE_SINT32         = 17,
    114     TYPE_SINT64         = 18,
    115     MAX_FIELD_TYPE      = 18,
    116   };
    117 
    118   // Lite alternative to FieldDescriptor::CppType.  Must be kept in sync.
    119   enum CppType {
    120     CPPTYPE_INT32       = 1,
    121     CPPTYPE_INT64       = 2,
    122     CPPTYPE_UINT32      = 3,
    123     CPPTYPE_UINT64      = 4,
    124     CPPTYPE_DOUBLE      = 5,
    125     CPPTYPE_FLOAT       = 6,
    126     CPPTYPE_BOOL        = 7,
    127     CPPTYPE_ENUM        = 8,
    128     CPPTYPE_STRING      = 9,
    129     CPPTYPE_MESSAGE     = 10,
    130     MAX_CPPTYPE         = 10,
    131   };
    132 
    133   // Helper method to get the CppType for a particular Type.
    134   static CppType FieldTypeToCppType(FieldType type);
    135 
    136   // Given a FieldSescriptor::Type return its WireType
    137   static inline WireFormatLite::WireType WireTypeForFieldType(
    138       WireFormatLite::FieldType type) {
    139     return kWireTypeForFieldType[type];
    140   }
    141 
    142   // Number of bits in a tag which identify the wire type.
    143   static const int kTagTypeBits = 3;
    144   // Mask for those bits.
    145   static const uint32 kTagTypeMask = (1 << kTagTypeBits) - 1;
    146 
    147   // Helper functions for encoding and decoding tags.  (Inlined below and in
    148   // _inl.h)
    149   //
    150   // This is different from MakeTag(field->number(), field->type()) in the case
    151   // of packed repeated fields.
    152   static uint32 MakeTag(int field_number, WireType type);
    153   static WireType GetTagWireType(uint32 tag);
    154   static int GetTagFieldNumber(uint32 tag);
    155 
    156   // Compute the byte size of a tag.  For groups, this includes both the start
    157   // and end tags.
    158   static inline int TagSize(int field_number, WireFormatLite::FieldType type);
    159 
    160   // Skips a field value with the given tag.  The input should start
    161   // positioned immediately after the tag.  Skipped values are simply discarded,
    162   // not recorded anywhere.  See WireFormat::SkipField() for a version that
    163   // records to an UnknownFieldSet.
    164   static bool SkipField(io::CodedInputStream* input, uint32 tag);
    165 
    166   // Skips a field value with the given tag.  The input should start
    167   // positioned immediately after the tag. Skipped values are recorded to a
    168   // CodedOutputStream.
    169   static bool SkipField(io::CodedInputStream* input, uint32 tag,
    170                         io::CodedOutputStream* output);
    171 
    172   // Reads and ignores a message from the input.  Skipped values are simply
    173   // discarded, not recorded anywhere.  See WireFormat::SkipMessage() for a
    174   // version that records to an UnknownFieldSet.
    175   static bool SkipMessage(io::CodedInputStream* input);
    176 
    177   // Reads and ignores a message from the input.  Skipped values are recorded
    178   // to a CodedOutputStream.
    179   static bool SkipMessage(io::CodedInputStream* input,
    180                           io::CodedOutputStream* output);
    181 
    182 // This macro does the same thing as WireFormatLite::MakeTag(), but the
    183 // result is usable as a compile-time constant, which makes it usable
    184 // as a switch case or a template input.  WireFormatLite::MakeTag() is more
    185 // type-safe, though, so prefer it if possible.
    186 #define GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(FIELD_NUMBER, TYPE)                  \
    187   static_cast<uint32>(                                                   \
    188     ((FIELD_NUMBER) << ::google::protobuf::internal::WireFormatLite::kTagTypeBits) \
    189       | (TYPE))
    190 
    191   // These are the tags for the old MessageSet format, which was defined as:
    192   //   message MessageSet {
    193   //     repeated group Item = 1 {
    194   //       required int32 type_id = 2;
    195   //       required string message = 3;
    196   //     }
    197   //   }
    198   static const int kMessageSetItemNumber = 1;
    199   static const int kMessageSetTypeIdNumber = 2;
    200   static const int kMessageSetMessageNumber = 3;
    201   static const int kMessageSetItemStartTag =
    202     GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(kMessageSetItemNumber,
    203                                 WireFormatLite::WIRETYPE_START_GROUP);
    204   static const int kMessageSetItemEndTag =
    205     GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(kMessageSetItemNumber,
    206                                 WireFormatLite::WIRETYPE_END_GROUP);
    207   static const int kMessageSetTypeIdTag =
    208     GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(kMessageSetTypeIdNumber,
    209                                 WireFormatLite::WIRETYPE_VARINT);
    210   static const int kMessageSetMessageTag =
    211     GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(kMessageSetMessageNumber,
    212                                 WireFormatLite::WIRETYPE_LENGTH_DELIMITED);
    213 
    214   // Byte size of all tags of a MessageSet::Item combined.
    215   static const int kMessageSetItemTagsSize;
    216 
    217   // Helper functions for converting between floats/doubles and IEEE-754
    218   // uint32s/uint64s so that they can be written.  (Assumes your platform
    219   // uses IEEE-754 floats.)
    220   static uint32 EncodeFloat(float value);
    221   static float DecodeFloat(uint32 value);
    222   static uint64 EncodeDouble(double value);
    223   static double DecodeDouble(uint64 value);
    224 
    225   // Helper functions for mapping signed integers to unsigned integers in
    226   // such a way that numbers with small magnitudes will encode to smaller
    227   // varints.  If you simply static_cast a negative number to an unsigned
    228   // number and varint-encode it, it will always take 10 bytes, defeating
    229   // the purpose of varint.  So, for the "sint32" and "sint64" field types,
    230   // we ZigZag-encode the values.
    231   static uint32 ZigZagEncode32(int32 n);
    232   static int32  ZigZagDecode32(uint32 n);
    233   static uint64 ZigZagEncode64(int64 n);
    234   static int64  ZigZagDecode64(uint64 n);
    235 
    236   // =================================================================
    237   // Methods for reading/writing individual field.  The implementations
    238   // of these methods are defined in wire_format_lite_inl.h; you must #include
    239   // that file to use these.
    240 
    241 // Avoid ugly line wrapping
    242 #define input  io::CodedInputStream*  input_arg
    243 #define output io::CodedOutputStream* output_arg
    244 #define field_number int field_number_arg
    245 #define INL GOOGLE_ATTRIBUTE_ALWAYS_INLINE
    246 
    247   // Read fields, not including tags.  The assumption is that you already
    248   // read the tag to determine what field to read.
    249 
    250   // For primitive fields, we just use a templatized routine parameterized by
    251   // the represented type and the FieldType. These are specialized with the
    252   // appropriate definition for each declared type.
    253   template <typename CType, enum FieldType DeclaredType> INL
    254   static bool ReadPrimitive(input, CType* value);
    255 
    256   // Reads repeated primitive values, with optimizations for repeats.
    257   // tag_size and tag should both be compile-time constants provided by the
    258   // protocol compiler.
    259   template <typename CType, enum FieldType DeclaredType> INL
    260   static bool ReadRepeatedPrimitive(int tag_size,
    261                                     uint32 tag,
    262                                     input,
    263                                     RepeatedField<CType>* value);
    264 
    265   // Identical to ReadRepeatedPrimitive, except will not inline the
    266   // implementation.
    267   template <typename CType, enum FieldType DeclaredType>
    268   static bool ReadRepeatedPrimitiveNoInline(int tag_size,
    269                                             uint32 tag,
    270                                             input,
    271                                             RepeatedField<CType>* value);
    272 
    273   // Reads a primitive value directly from the provided buffer. It returns a
    274   // pointer past the segment of data that was read.
    275   //
    276   // This is only implemented for the types with fixed wire size, e.g.
    277   // float, double, and the (s)fixed* types.
    278   template <typename CType, enum FieldType DeclaredType> INL
    279   static const uint8* ReadPrimitiveFromArray(const uint8* buffer, CType* value);
    280 
    281   // Reads a primitive packed field.
    282   //
    283   // This is only implemented for packable types.
    284   template <typename CType, enum FieldType DeclaredType> INL
    285   static bool ReadPackedPrimitive(input, RepeatedField<CType>* value);
    286 
    287   // Identical to ReadPackedPrimitive, except will not inline the
    288   // implementation.
    289   template <typename CType, enum FieldType DeclaredType>
    290   static bool ReadPackedPrimitiveNoInline(input, RepeatedField<CType>* value);
    291 
    292   // Read a packed enum field. If the is_valid function is not NULL, values for
    293   // which is_valid(value) returns false are silently dropped.
    294   static bool ReadPackedEnumNoInline(input,
    295                                      bool (*is_valid)(int),
    296                                      RepeatedField<int>* values);
    297 
    298   // Read a packed enum field. If the is_valid function is not NULL, values for
    299   // which is_valid(value) returns false are appended to unknown_fields_stream.
    300   static bool ReadPackedEnumPreserveUnknowns(
    301       input,
    302       field_number,
    303       bool (*is_valid)(int),
    304       io::CodedOutputStream* unknown_fields_stream,
    305       RepeatedField<int>* values);
    306 
    307   // Read a string.  ReadString(..., string* value) requires an existing string.
    308   static inline bool ReadString(input, string* value);
    309   // ReadString(..., string** p) is internal-only, and should only be called
    310   // from generated code. It starts by setting *p to "new string"
    311   // if *p == &GetEmptyStringAlreadyInited().  It then invokes
    312   // ReadString(input, *p).  This is useful for reducing code size.
    313   static inline bool ReadString(input, string** p);
    314   // Analogous to ReadString().
    315   static bool ReadBytes(input, string* value);
    316   static bool ReadBytes(input, string** p);
    317 
    318 
    319   enum Operation {
    320     PARSE = 0,
    321     SERIALIZE = 1,
    322   };
    323 
    324   // Returns true if the data is valid UTF-8.
    325   static bool VerifyUtf8String(const char* data, int size,
    326                                Operation op,
    327                                const char* field_name);
    328 
    329   static inline bool ReadGroup  (field_number, input, MessageLite* value);
    330   static inline bool ReadMessage(input, MessageLite* value);
    331 
    332   // Like above, but de-virtualize the call to MergePartialFromCodedStream().
    333   // The pointer must point at an instance of MessageType, *not* a subclass (or
    334   // the subclass must not override MergePartialFromCodedStream()).
    335   template<typename MessageType>
    336   static inline bool ReadGroupNoVirtual(field_number, input,
    337                                         MessageType* value);
    338   template<typename MessageType>
    339   static inline bool ReadMessageNoVirtual(input, MessageType* value);
    340 
    341   // The same, but do not modify input's recursion depth.  This is useful
    342   // when reading a bunch of groups or messages in a loop, because then the
    343   // recursion depth can be incremented before the loop and decremented after.
    344   template<typename MessageType>
    345   static inline bool ReadGroupNoVirtualNoRecursionDepth(field_number, input,
    346                                                         MessageType* value);
    347 
    348   template<typename MessageType>
    349   static inline bool ReadMessageNoVirtualNoRecursionDepth(input,
    350                                                           MessageType* value);
    351 
    352   // Write a tag.  The Write*() functions typically include the tag, so
    353   // normally there's no need to call this unless using the Write*NoTag()
    354   // variants.
    355   INL static void WriteTag(field_number, WireType type, output);
    356 
    357   // Write fields, without tags.
    358   INL static void WriteInt32NoTag   (int32 value, output);
    359   INL static void WriteInt64NoTag   (int64 value, output);
    360   INL static void WriteUInt32NoTag  (uint32 value, output);
    361   INL static void WriteUInt64NoTag  (uint64 value, output);
    362   INL static void WriteSInt32NoTag  (int32 value, output);
    363   INL static void WriteSInt64NoTag  (int64 value, output);
    364   INL static void WriteFixed32NoTag (uint32 value, output);
    365   INL static void WriteFixed64NoTag (uint64 value, output);
    366   INL static void WriteSFixed32NoTag(int32 value, output);
    367   INL static void WriteSFixed64NoTag(int64 value, output);
    368   INL static void WriteFloatNoTag   (float value, output);
    369   INL static void WriteDoubleNoTag  (double value, output);
    370   INL static void WriteBoolNoTag    (bool value, output);
    371   INL static void WriteEnumNoTag    (int value, output);
    372 
    373   // Write fields, including tags.
    374   static void WriteInt32   (field_number,  int32 value, output);
    375   static void WriteInt64   (field_number,  int64 value, output);
    376   static void WriteUInt32  (field_number, uint32 value, output);
    377   static void WriteUInt64  (field_number, uint64 value, output);
    378   static void WriteSInt32  (field_number,  int32 value, output);
    379   static void WriteSInt64  (field_number,  int64 value, output);
    380   static void WriteFixed32 (field_number, uint32 value, output);
    381   static void WriteFixed64 (field_number, uint64 value, output);
    382   static void WriteSFixed32(field_number,  int32 value, output);
    383   static void WriteSFixed64(field_number,  int64 value, output);
    384   static void WriteFloat   (field_number,  float value, output);
    385   static void WriteDouble  (field_number, double value, output);
    386   static void WriteBool    (field_number,   bool value, output);
    387   static void WriteEnum    (field_number,    int value, output);
    388 
    389   static void WriteString(field_number, const string& value, output);
    390   static void WriteBytes (field_number, const string& value, output);
    391   static void WriteStringMaybeAliased(
    392       field_number, const string& value, output);
    393   static void WriteBytesMaybeAliased(
    394       field_number, const string& value, output);
    395 
    396   static void WriteGroup(
    397     field_number, const MessageLite& value, output);
    398   static void WriteMessage(
    399     field_number, const MessageLite& value, output);
    400   // Like above, but these will check if the output stream has enough
    401   // space to write directly to a flat array.
    402   static void WriteGroupMaybeToArray(
    403     field_number, const MessageLite& value, output);
    404   static void WriteMessageMaybeToArray(
    405     field_number, const MessageLite& value, output);
    406 
    407   // Like above, but de-virtualize the call to SerializeWithCachedSizes().  The
    408   // pointer must point at an instance of MessageType, *not* a subclass (or
    409   // the subclass must not override SerializeWithCachedSizes()).
    410   template<typename MessageType>
    411   static inline void WriteGroupNoVirtual(
    412     field_number, const MessageType& value, output);
    413   template<typename MessageType>
    414   static inline void WriteMessageNoVirtual(
    415     field_number, const MessageType& value, output);
    416 
    417 #undef output
    418 #define output uint8* target
    419 
    420   // Like above, but use only *ToArray methods of CodedOutputStream.
    421   INL static uint8* WriteTagToArray(field_number, WireType type, output);
    422 
    423   // Write fields, without tags.
    424   INL static uint8* WriteInt32NoTagToArray   (int32 value, output);
    425   INL static uint8* WriteInt64NoTagToArray   (int64 value, output);
    426   INL static uint8* WriteUInt32NoTagToArray  (uint32 value, output);
    427   INL static uint8* WriteUInt64NoTagToArray  (uint64 value, output);
    428   INL static uint8* WriteSInt32NoTagToArray  (int32 value, output);
    429   INL static uint8* WriteSInt64NoTagToArray  (int64 value, output);
    430   INL static uint8* WriteFixed32NoTagToArray (uint32 value, output);
    431   INL static uint8* WriteFixed64NoTagToArray (uint64 value, output);
    432   INL static uint8* WriteSFixed32NoTagToArray(int32 value, output);
    433   INL static uint8* WriteSFixed64NoTagToArray(int64 value, output);
    434   INL static uint8* WriteFloatNoTagToArray   (float value, output);
    435   INL static uint8* WriteDoubleNoTagToArray  (double value, output);
    436   INL static uint8* WriteBoolNoTagToArray    (bool value, output);
    437   INL static uint8* WriteEnumNoTagToArray    (int value, output);
    438 
    439   // Write fields, including tags.
    440   INL static uint8* WriteInt32ToArray(field_number, int32 value, output);
    441   INL static uint8* WriteInt64ToArray(field_number, int64 value, output);
    442   INL static uint8* WriteUInt32ToArray(field_number, uint32 value, output);
    443   INL static uint8* WriteUInt64ToArray(field_number, uint64 value, output);
    444   INL static uint8* WriteSInt32ToArray(field_number, int32 value, output);
    445   INL static uint8* WriteSInt64ToArray(field_number, int64 value, output);
    446   INL static uint8* WriteFixed32ToArray(field_number, uint32 value, output);
    447   INL static uint8* WriteFixed64ToArray(field_number, uint64 value, output);
    448   INL static uint8* WriteSFixed32ToArray(field_number, int32 value, output);
    449   INL static uint8* WriteSFixed64ToArray(field_number, int64 value, output);
    450   INL static uint8* WriteFloatToArray(field_number, float value, output);
    451   INL static uint8* WriteDoubleToArray(field_number, double value, output);
    452   INL static uint8* WriteBoolToArray(field_number, bool value, output);
    453   INL static uint8* WriteEnumToArray(field_number, int value, output);
    454 
    455   INL static uint8* WriteStringToArray(
    456     field_number, const string& value, output);
    457   INL static uint8* WriteBytesToArray(
    458     field_number, const string& value, output);
    459 
    460   INL static uint8* WriteGroupToArray(
    461       field_number, const MessageLite& value, output);
    462   INL static uint8* WriteMessageToArray(
    463       field_number, const MessageLite& value, output);
    464 
    465   // Like above, but de-virtualize the call to SerializeWithCachedSizes().  The
    466   // pointer must point at an instance of MessageType, *not* a subclass (or
    467   // the subclass must not override SerializeWithCachedSizes()).
    468   template<typename MessageType>
    469   INL static uint8* WriteGroupNoVirtualToArray(
    470     field_number, const MessageType& value, output);
    471   template<typename MessageType>
    472   INL static uint8* WriteMessageNoVirtualToArray(
    473     field_number, const MessageType& value, output);
    474 
    475 #undef output
    476 #undef input
    477 #undef INL
    478 
    479 #undef field_number
    480 
    481   // Compute the byte size of a field.  The XxSize() functions do NOT include
    482   // the tag, so you must also call TagSize().  (This is because, for repeated
    483   // fields, you should only call TagSize() once and multiply it by the element
    484   // count, but you may have to call XxSize() for each individual element.)
    485   static inline int Int32Size   ( int32 value);
    486   static inline int Int64Size   ( int64 value);
    487   static inline int UInt32Size  (uint32 value);
    488   static inline int UInt64Size  (uint64 value);
    489   static inline int SInt32Size  ( int32 value);
    490   static inline int SInt64Size  ( int64 value);
    491   static inline int EnumSize    (   int value);
    492 
    493   // These types always have the same size.
    494   static const int kFixed32Size  = 4;
    495   static const int kFixed64Size  = 8;
    496   static const int kSFixed32Size = 4;
    497   static const int kSFixed64Size = 8;
    498   static const int kFloatSize    = 4;
    499   static const int kDoubleSize   = 8;
    500   static const int kBoolSize     = 1;
    501 
    502   static inline int StringSize(const string& value);
    503   static inline int BytesSize (const string& value);
    504 
    505   static inline int GroupSize  (const MessageLite& value);
    506   static inline int MessageSize(const MessageLite& value);
    507 
    508   // Like above, but de-virtualize the call to ByteSize().  The
    509   // pointer must point at an instance of MessageType, *not* a subclass (or
    510   // the subclass must not override ByteSize()).
    511   template<typename MessageType>
    512   static inline int GroupSizeNoVirtual  (const MessageType& value);
    513   template<typename MessageType>
    514   static inline int MessageSizeNoVirtual(const MessageType& value);
    515 
    516   // Given the length of data, calculate the byte size of the data on the
    517   // wire if we encode the data as a length delimited field.
    518   static inline int LengthDelimitedSize(int length);
    519 
    520  private:
    521   // A helper method for the repeated primitive reader. This method has
    522   // optimizations for primitive types that have fixed size on the wire, and
    523   // can be read using potentially faster paths.
    524   template <typename CType, enum FieldType DeclaredType> GOOGLE_ATTRIBUTE_ALWAYS_INLINE
    525   static bool ReadRepeatedFixedSizePrimitive(
    526       int tag_size,
    527       uint32 tag,
    528       google::protobuf::io::CodedInputStream* input,
    529       RepeatedField<CType>* value);
    530 
    531   // Like ReadRepeatedFixedSizePrimitive but for packed primitive fields.
    532   template <typename CType, enum FieldType DeclaredType> GOOGLE_ATTRIBUTE_ALWAYS_INLINE
    533   static bool ReadPackedFixedSizePrimitive(google::protobuf::io::CodedInputStream* input,
    534                                            RepeatedField<CType>* value);
    535 
    536   static const CppType kFieldTypeToCppTypeMap[];
    537   static const WireFormatLite::WireType kWireTypeForFieldType[];
    538 
    539   GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(WireFormatLite);
    540 };
    541 
    542 // A class which deals with unknown values.  The default implementation just
    543 // discards them.  WireFormat defines a subclass which writes to an
    544 // UnknownFieldSet.  This class is used by ExtensionSet::ParseField(), since
    545 // ExtensionSet is part of the lite library but UnknownFieldSet is not.
    546 class LIBPROTOBUF_EXPORT FieldSkipper {
    547  public:
    548   FieldSkipper() {}
    549   virtual ~FieldSkipper() {}
    550 
    551   // Skip a field whose tag has already been consumed.
    552   virtual bool SkipField(io::CodedInputStream* input, uint32 tag);
    553 
    554   // Skip an entire message or group, up to an end-group tag (which is consumed)
    555   // or end-of-stream.
    556   virtual bool SkipMessage(io::CodedInputStream* input);
    557 
    558   // Deal with an already-parsed unrecognized enum value.  The default
    559   // implementation does nothing, but the UnknownFieldSet-based implementation
    560   // saves it as an unknown varint.
    561   virtual void SkipUnknownEnum(int field_number, int value);
    562 };
    563 
    564 // Subclass of FieldSkipper which saves skipped fields to a CodedOutputStream.
    565 
    566 class LIBPROTOBUF_EXPORT CodedOutputStreamFieldSkipper : public FieldSkipper {
    567  public:
    568   explicit CodedOutputStreamFieldSkipper(io::CodedOutputStream* unknown_fields)
    569       : unknown_fields_(unknown_fields) {}
    570   virtual ~CodedOutputStreamFieldSkipper() {}
    571 
    572   // implements FieldSkipper -----------------------------------------
    573   virtual bool SkipField(io::CodedInputStream* input, uint32 tag);
    574   virtual bool SkipMessage(io::CodedInputStream* input);
    575   virtual void SkipUnknownEnum(int field_number, int value);
    576 
    577  protected:
    578   io::CodedOutputStream* unknown_fields_;
    579 };
    580 
    581 
    582 // inline methods ====================================================
    583 
    584 inline WireFormatLite::CppType
    585 WireFormatLite::FieldTypeToCppType(FieldType type) {
    586   return kFieldTypeToCppTypeMap[type];
    587 }
    588 
    589 inline uint32 WireFormatLite::MakeTag(int field_number, WireType type) {
    590   return GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(field_number, type);
    591 }
    592 
    593 inline WireFormatLite::WireType WireFormatLite::GetTagWireType(uint32 tag) {
    594   return static_cast<WireType>(tag & kTagTypeMask);
    595 }
    596 
    597 inline int WireFormatLite::GetTagFieldNumber(uint32 tag) {
    598   return static_cast<int>(tag >> kTagTypeBits);
    599 }
    600 
    601 inline int WireFormatLite::TagSize(int field_number,
    602                                    WireFormatLite::FieldType type) {
    603   int result = io::CodedOutputStream::VarintSize32(
    604     field_number << kTagTypeBits);
    605   if (type == TYPE_GROUP) {
    606     // Groups have both a start and an end tag.
    607     return result * 2;
    608   } else {
    609     return result;
    610   }
    611 }
    612 
    613 inline uint32 WireFormatLite::EncodeFloat(float value) {
    614   union {float f; uint32 i;};
    615   f = value;
    616   return i;
    617 }
    618 
    619 inline float WireFormatLite::DecodeFloat(uint32 value) {
    620   union {float f; uint32 i;};
    621   i = value;
    622   return f;
    623 }
    624 
    625 inline uint64 WireFormatLite::EncodeDouble(double value) {
    626   union {double f; uint64 i;};
    627   f = value;
    628   return i;
    629 }
    630 
    631 inline double WireFormatLite::DecodeDouble(uint64 value) {
    632   union {double f; uint64 i;};
    633   i = value;
    634   return f;
    635 }
    636 
    637 // ZigZag Transform:  Encodes signed integers so that they can be
    638 // effectively used with varint encoding.
    639 //
    640 // varint operates on unsigned integers, encoding smaller numbers into
    641 // fewer bytes.  If you try to use it on a signed integer, it will treat
    642 // this number as a very large unsigned integer, which means that even
    643 // small signed numbers like -1 will take the maximum number of bytes
    644 // (10) to encode.  ZigZagEncode() maps signed integers to unsigned
    645 // in such a way that those with a small absolute value will have smaller
    646 // encoded values, making them appropriate for encoding using varint.
    647 //
    648 //       int32 ->     uint32
    649 // -------------------------
    650 //           0 ->          0
    651 //          -1 ->          1
    652 //           1 ->          2
    653 //          -2 ->          3
    654 //         ... ->        ...
    655 //  2147483647 -> 4294967294
    656 // -2147483648 -> 4294967295
    657 //
    658 //        >> encode >>
    659 //        << decode <<
    660 
    661 inline uint32 WireFormatLite::ZigZagEncode32(int32 n) {
    662   // Note:  the right-shift must be arithmetic
    663   return (static_cast<uint32>(n) << 1) ^ (n >> 31);
    664 }
    665 
    666 inline int32 WireFormatLite::ZigZagDecode32(uint32 n) {
    667   return (n >> 1) ^ -static_cast<int32>(n & 1);
    668 }
    669 
    670 inline uint64 WireFormatLite::ZigZagEncode64(int64 n) {
    671   // Note:  the right-shift must be arithmetic
    672   return (static_cast<uint64>(n) << 1) ^ (n >> 63);
    673 }
    674 
    675 inline int64 WireFormatLite::ZigZagDecode64(uint64 n) {
    676   return (n >> 1) ^ -static_cast<int64>(n & 1);
    677 }
    678 
    679 // String is for UTF-8 text only, but, even so, ReadString() can simply
    680 // call ReadBytes().
    681 
    682 inline bool WireFormatLite::ReadString(io::CodedInputStream* input,
    683                                        string* value) {
    684   return ReadBytes(input, value);
    685 }
    686 
    687 inline bool WireFormatLite::ReadString(io::CodedInputStream* input,
    688                                        string** p) {
    689   return ReadBytes(input, p);
    690 }
    691 
    692 }  // namespace internal
    693 }  // namespace protobuf
    694 
    695 }  // namespace google
    696 #endif  // GOOGLE_PROTOBUF_WIRE_FORMAT_LITE_H__
    697