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 (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 // Reads and ignores a message from the input. Skipped values are simply 167 // discarded, not recorded anywhere. See WireFormat::SkipMessage() for a 168 // version that records to an UnknownFieldSet. 169 static bool SkipMessage(io::CodedInputStream* input); 170 171 // This macro does the same thing as WireFormatLite::MakeTag(), but the 172 // result is usable as a compile-time constant, which makes it usable 173 // as a switch case or a template input. WireFormatLite::MakeTag() is more 174 // type-safe, though, so prefer it if possible. 175 #define GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(FIELD_NUMBER, TYPE) \ 176 static_cast<uint32>( \ 177 ((FIELD_NUMBER) << ::google::protobuf::internal::WireFormatLite::kTagTypeBits) \ 178 | (TYPE)) 179 180 // These are the tags for the old MessageSet format, which was defined as: 181 // message MessageSet { 182 // repeated group Item = 1 { 183 // required int32 type_id = 2; 184 // required string message = 3; 185 // } 186 // } 187 static const int kMessageSetItemNumber = 1; 188 static const int kMessageSetTypeIdNumber = 2; 189 static const int kMessageSetMessageNumber = 3; 190 static const int kMessageSetItemStartTag = 191 GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(kMessageSetItemNumber, 192 WireFormatLite::WIRETYPE_START_GROUP); 193 static const int kMessageSetItemEndTag = 194 GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(kMessageSetItemNumber, 195 WireFormatLite::WIRETYPE_END_GROUP); 196 static const int kMessageSetTypeIdTag = 197 GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(kMessageSetTypeIdNumber, 198 WireFormatLite::WIRETYPE_VARINT); 199 static const int kMessageSetMessageTag = 200 GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(kMessageSetMessageNumber, 201 WireFormatLite::WIRETYPE_LENGTH_DELIMITED); 202 203 // Byte size of all tags of a MessageSet::Item combined. 204 static const int kMessageSetItemTagsSize; 205 206 // Helper functions for converting between floats/doubles and IEEE-754 207 // uint32s/uint64s so that they can be written. (Assumes your platform 208 // uses IEEE-754 floats.) 209 static uint32 EncodeFloat(float value); 210 static float DecodeFloat(uint32 value); 211 static uint64 EncodeDouble(double value); 212 static double DecodeDouble(uint64 value); 213 214 // Helper functions for mapping signed integers to unsigned integers in 215 // such a way that numbers with small magnitudes will encode to smaller 216 // varints. If you simply static_cast a negative number to an unsigned 217 // number and varint-encode it, it will always take 10 bytes, defeating 218 // the purpose of varint. So, for the "sint32" and "sint64" field types, 219 // we ZigZag-encode the values. 220 static uint32 ZigZagEncode32(int32 n); 221 static int32 ZigZagDecode32(uint32 n); 222 static uint64 ZigZagEncode64(int64 n); 223 static int64 ZigZagDecode64(uint64 n); 224 225 // ================================================================= 226 // Methods for reading/writing individual field. The implementations 227 // of these methods are defined in wire_format_lite_inl.h; you must #include 228 // that file to use these. 229 230 // Avoid ugly line wrapping 231 #define input io::CodedInputStream* input 232 #define output io::CodedOutputStream* output 233 #define field_number int field_number 234 #define INL GOOGLE_ATTRIBUTE_ALWAYS_INLINE 235 236 // Read fields, not including tags. The assumption is that you already 237 // read the tag to determine what field to read. 238 239 // For primitive fields, we just use a templatized routine parameterized by 240 // the represented type and the FieldType. These are specialized with the 241 // appropriate definition for each declared type. 242 template <typename CType, enum FieldType DeclaredType> 243 static inline bool ReadPrimitive(input, CType* value) INL; 244 245 // Reads repeated primitive values, with optimizations for repeats. 246 // tag_size and tag should both be compile-time constants provided by the 247 // protocol compiler. 248 template <typename CType, enum FieldType DeclaredType> 249 static inline bool ReadRepeatedPrimitive(int tag_size, 250 uint32 tag, 251 input, 252 RepeatedField<CType>* value) INL; 253 254 // Identical to ReadRepeatedPrimitive, except will not inline the 255 // implementation. 256 template <typename CType, enum FieldType DeclaredType> 257 static bool ReadRepeatedPrimitiveNoInline(int tag_size, 258 uint32 tag, 259 input, 260 RepeatedField<CType>* value); 261 262 // Reads a primitive value directly from the provided buffer. It returns a 263 // pointer past the segment of data that was read. 264 // 265 // This is only implemented for the types with fixed wire size, e.g. 266 // float, double, and the (s)fixed* types. 267 template <typename CType, enum FieldType DeclaredType> 268 static inline const uint8* ReadPrimitiveFromArray(const uint8* buffer, 269 CType* value) INL; 270 271 // Reads a primitive packed field. 272 // 273 // This is only implemented for packable types. 274 template <typename CType, enum FieldType DeclaredType> 275 static inline bool ReadPackedPrimitive(input, 276 RepeatedField<CType>* value) INL; 277 278 // Identical to ReadPackedPrimitive, except will not inline the 279 // implementation. 280 template <typename CType, enum FieldType DeclaredType> 281 static bool ReadPackedPrimitiveNoInline(input, RepeatedField<CType>* value); 282 283 // Read a packed enum field. Values for which is_valid() returns false are 284 // dropped. 285 static bool ReadPackedEnumNoInline(input, 286 bool (*is_valid)(int), 287 RepeatedField<int>* value); 288 289 static bool ReadString(input, string* value); 290 static bool ReadBytes (input, string* value); 291 292 static inline bool ReadGroup (field_number, input, MessageLite* value); 293 static inline bool ReadMessage(input, MessageLite* value); 294 295 // Like above, but de-virtualize the call to MergePartialFromCodedStream(). 296 // The pointer must point at an instance of MessageType, *not* a subclass (or 297 // the subclass must not override MergePartialFromCodedStream()). 298 template<typename MessageType> 299 static inline bool ReadGroupNoVirtual(field_number, input, 300 MessageType* value); 301 template<typename MessageType> 302 static inline bool ReadMessageNoVirtual(input, MessageType* value); 303 304 // Write a tag. The Write*() functions typically include the tag, so 305 // normally there's no need to call this unless using the Write*NoTag() 306 // variants. 307 static inline void WriteTag(field_number, WireType type, output) INL; 308 309 // Write fields, without tags. 310 static inline void WriteInt32NoTag (int32 value, output) INL; 311 static inline void WriteInt64NoTag (int64 value, output) INL; 312 static inline void WriteUInt32NoTag (uint32 value, output) INL; 313 static inline void WriteUInt64NoTag (uint64 value, output) INL; 314 static inline void WriteSInt32NoTag (int32 value, output) INL; 315 static inline void WriteSInt64NoTag (int64 value, output) INL; 316 static inline void WriteFixed32NoTag (uint32 value, output) INL; 317 static inline void WriteFixed64NoTag (uint64 value, output) INL; 318 static inline void WriteSFixed32NoTag(int32 value, output) INL; 319 static inline void WriteSFixed64NoTag(int64 value, output) INL; 320 static inline void WriteFloatNoTag (float value, output) INL; 321 static inline void WriteDoubleNoTag (double value, output) INL; 322 static inline void WriteBoolNoTag (bool value, output) INL; 323 static inline void WriteEnumNoTag (int value, output) INL; 324 325 // Write fields, including tags. 326 static void WriteInt32 (field_number, int32 value, output); 327 static void WriteInt64 (field_number, int64 value, output); 328 static void WriteUInt32 (field_number, uint32 value, output); 329 static void WriteUInt64 (field_number, uint64 value, output); 330 static void WriteSInt32 (field_number, int32 value, output); 331 static void WriteSInt64 (field_number, int64 value, output); 332 static void WriteFixed32 (field_number, uint32 value, output); 333 static void WriteFixed64 (field_number, uint64 value, output); 334 static void WriteSFixed32(field_number, int32 value, output); 335 static void WriteSFixed64(field_number, int64 value, output); 336 static void WriteFloat (field_number, float value, output); 337 static void WriteDouble (field_number, double value, output); 338 static void WriteBool (field_number, bool value, output); 339 static void WriteEnum (field_number, int value, output); 340 341 static void WriteString(field_number, const string& value, output); 342 static void WriteBytes (field_number, const string& value, output); 343 344 static void WriteGroup( 345 field_number, const MessageLite& value, output); 346 static void WriteMessage( 347 field_number, const MessageLite& value, output); 348 // Like above, but these will check if the output stream has enough 349 // space to write directly to a flat array. 350 static void WriteGroupMaybeToArray( 351 field_number, const MessageLite& value, output); 352 static void WriteMessageMaybeToArray( 353 field_number, const MessageLite& value, output); 354 355 // Like above, but de-virtualize the call to SerializeWithCachedSizes(). The 356 // pointer must point at an instance of MessageType, *not* a subclass (or 357 // the subclass must not override SerializeWithCachedSizes()). 358 template<typename MessageType> 359 static inline void WriteGroupNoVirtual( 360 field_number, const MessageType& value, output); 361 template<typename MessageType> 362 static inline void WriteMessageNoVirtual( 363 field_number, const MessageType& value, output); 364 365 #undef output 366 #define output uint8* target 367 368 // Like above, but use only *ToArray methods of CodedOutputStream. 369 static inline uint8* WriteTagToArray(field_number, WireType type, output) INL; 370 371 // Write fields, without tags. 372 static inline uint8* WriteInt32NoTagToArray (int32 value, output) INL; 373 static inline uint8* WriteInt64NoTagToArray (int64 value, output) INL; 374 static inline uint8* WriteUInt32NoTagToArray (uint32 value, output) INL; 375 static inline uint8* WriteUInt64NoTagToArray (uint64 value, output) INL; 376 static inline uint8* WriteSInt32NoTagToArray (int32 value, output) INL; 377 static inline uint8* WriteSInt64NoTagToArray (int64 value, output) INL; 378 static inline uint8* WriteFixed32NoTagToArray (uint32 value, output) INL; 379 static inline uint8* WriteFixed64NoTagToArray (uint64 value, output) INL; 380 static inline uint8* WriteSFixed32NoTagToArray(int32 value, output) INL; 381 static inline uint8* WriteSFixed64NoTagToArray(int64 value, output) INL; 382 static inline uint8* WriteFloatNoTagToArray (float value, output) INL; 383 static inline uint8* WriteDoubleNoTagToArray (double value, output) INL; 384 static inline uint8* WriteBoolNoTagToArray (bool value, output) INL; 385 static inline uint8* WriteEnumNoTagToArray (int value, output) INL; 386 387 // Write fields, including tags. 388 static inline uint8* WriteInt32ToArray( 389 field_number, int32 value, output) INL; 390 static inline uint8* WriteInt64ToArray( 391 field_number, int64 value, output) INL; 392 static inline uint8* WriteUInt32ToArray( 393 field_number, uint32 value, output) INL; 394 static inline uint8* WriteUInt64ToArray( 395 field_number, uint64 value, output) INL; 396 static inline uint8* WriteSInt32ToArray( 397 field_number, int32 value, output) INL; 398 static inline uint8* WriteSInt64ToArray( 399 field_number, int64 value, output) INL; 400 static inline uint8* WriteFixed32ToArray( 401 field_number, uint32 value, output) INL; 402 static inline uint8* WriteFixed64ToArray( 403 field_number, uint64 value, output) INL; 404 static inline uint8* WriteSFixed32ToArray( 405 field_number, int32 value, output) INL; 406 static inline uint8* WriteSFixed64ToArray( 407 field_number, int64 value, output) INL; 408 static inline uint8* WriteFloatToArray( 409 field_number, float value, output) INL; 410 static inline uint8* WriteDoubleToArray( 411 field_number, double value, output) INL; 412 static inline uint8* WriteBoolToArray( 413 field_number, bool value, output) INL; 414 static inline uint8* WriteEnumToArray( 415 field_number, int value, output) INL; 416 417 static inline uint8* WriteStringToArray( 418 field_number, const string& value, output) INL; 419 static inline uint8* WriteBytesToArray( 420 field_number, const string& value, output) INL; 421 422 static inline uint8* WriteGroupToArray( 423 field_number, const MessageLite& value, output) INL; 424 static inline uint8* WriteMessageToArray( 425 field_number, const MessageLite& value, output) INL; 426 427 // Like above, but de-virtualize the call to SerializeWithCachedSizes(). The 428 // pointer must point at an instance of MessageType, *not* a subclass (or 429 // the subclass must not override SerializeWithCachedSizes()). 430 template<typename MessageType> 431 static inline uint8* WriteGroupNoVirtualToArray( 432 field_number, const MessageType& value, output) INL; 433 template<typename MessageType> 434 static inline uint8* WriteMessageNoVirtualToArray( 435 field_number, const MessageType& value, output) INL; 436 437 #undef output 438 #undef input 439 #undef INL 440 441 #undef field_number 442 443 // Compute the byte size of a field. The XxSize() functions do NOT include 444 // the tag, so you must also call TagSize(). (This is because, for repeated 445 // fields, you should only call TagSize() once and multiply it by the element 446 // count, but you may have to call XxSize() for each individual element.) 447 static inline int Int32Size ( int32 value); 448 static inline int Int64Size ( int64 value); 449 static inline int UInt32Size (uint32 value); 450 static inline int UInt64Size (uint64 value); 451 static inline int SInt32Size ( int32 value); 452 static inline int SInt64Size ( int64 value); 453 static inline int EnumSize ( int value); 454 455 // These types always have the same size. 456 static const int kFixed32Size = 4; 457 static const int kFixed64Size = 8; 458 static const int kSFixed32Size = 4; 459 static const int kSFixed64Size = 8; 460 static const int kFloatSize = 4; 461 static const int kDoubleSize = 8; 462 static const int kBoolSize = 1; 463 464 static inline int StringSize(const string& value); 465 static inline int BytesSize (const string& value); 466 467 static inline int GroupSize (const MessageLite& value); 468 static inline int MessageSize(const MessageLite& value); 469 470 // Like above, but de-virtualize the call to ByteSize(). The 471 // pointer must point at an instance of MessageType, *not* a subclass (or 472 // the subclass must not override ByteSize()). 473 template<typename MessageType> 474 static inline int GroupSizeNoVirtual (const MessageType& value); 475 template<typename MessageType> 476 static inline int MessageSizeNoVirtual(const MessageType& value); 477 478 // Given the length of data, calculate the byte size of the data on the 479 // wire if we encode the data as a length delimited field. 480 static inline int LengthDelimitedSize(int length); 481 482 private: 483 // A helper method for the repeated primitive reader. This method has 484 // optimizations for primitive types that have fixed size on the wire, and 485 // can be read using potentially faster paths. 486 template <typename CType, enum FieldType DeclaredType> 487 static inline bool ReadRepeatedFixedSizePrimitive( 488 int tag_size, 489 uint32 tag, 490 google::protobuf::io::CodedInputStream* input, 491 RepeatedField<CType>* value) GOOGLE_ATTRIBUTE_ALWAYS_INLINE; 492 493 static const CppType kFieldTypeToCppTypeMap[]; 494 static const WireFormatLite::WireType kWireTypeForFieldType[]; 495 496 GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(WireFormatLite); 497 }; 498 499 // A class which deals with unknown values. The default implementation just 500 // discards them. WireFormat defines a subclass which writes to an 501 // UnknownFieldSet. This class is used by ExtensionSet::ParseField(), since 502 // ExtensionSet is part of the lite library but UnknownFieldSet is not. 503 class LIBPROTOBUF_EXPORT FieldSkipper { 504 public: 505 FieldSkipper() {} 506 virtual ~FieldSkipper() {} 507 508 // Skip a field whose tag has already been consumed. 509 virtual bool SkipField(io::CodedInputStream* input, uint32 tag); 510 511 // Skip an entire message or group, up to an end-group tag (which is consumed) 512 // or end-of-stream. 513 virtual bool SkipMessage(io::CodedInputStream* input); 514 515 // Deal with an already-parsed unrecognized enum value. The default 516 // implementation does nothing, but the UnknownFieldSet-based implementation 517 // saves it as an unknown varint. 518 virtual void SkipUnknownEnum(int field_number, int value); 519 }; 520 521 // inline methods ==================================================== 522 523 inline WireFormatLite::CppType 524 WireFormatLite::FieldTypeToCppType(FieldType type) { 525 return kFieldTypeToCppTypeMap[type]; 526 } 527 528 inline uint32 WireFormatLite::MakeTag(int field_number, WireType type) { 529 return GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(field_number, type); 530 } 531 532 inline WireFormatLite::WireType WireFormatLite::GetTagWireType(uint32 tag) { 533 return static_cast<WireType>(tag & kTagTypeMask); 534 } 535 536 inline int WireFormatLite::GetTagFieldNumber(uint32 tag) { 537 return static_cast<int>(tag >> kTagTypeBits); 538 } 539 540 inline int WireFormatLite::TagSize(int field_number, 541 WireFormatLite::FieldType type) { 542 int result = io::CodedOutputStream::VarintSize32( 543 field_number << kTagTypeBits); 544 if (type == TYPE_GROUP) { 545 // Groups have both a start and an end tag. 546 return result * 2; 547 } else { 548 return result; 549 } 550 } 551 552 inline uint32 WireFormatLite::EncodeFloat(float value) { 553 union {float f; uint32 i;}; 554 f = value; 555 return i; 556 } 557 558 inline float WireFormatLite::DecodeFloat(uint32 value) { 559 union {float f; uint32 i;}; 560 i = value; 561 return f; 562 } 563 564 inline uint64 WireFormatLite::EncodeDouble(double value) { 565 union {double f; uint64 i;}; 566 f = value; 567 return i; 568 } 569 570 inline double WireFormatLite::DecodeDouble(uint64 value) { 571 union {double f; uint64 i;}; 572 i = value; 573 return f; 574 } 575 576 // ZigZag Transform: Encodes signed integers so that they can be 577 // effectively used with varint encoding. 578 // 579 // varint operates on unsigned integers, encoding smaller numbers into 580 // fewer bytes. If you try to use it on a signed integer, it will treat 581 // this number as a very large unsigned integer, which means that even 582 // small signed numbers like -1 will take the maximum number of bytes 583 // (10) to encode. ZigZagEncode() maps signed integers to unsigned 584 // in such a way that those with a small absolute value will have smaller 585 // encoded values, making them appropriate for encoding using varint. 586 // 587 // int32 -> uint32 588 // ------------------------- 589 // 0 -> 0 590 // -1 -> 1 591 // 1 -> 2 592 // -2 -> 3 593 // ... -> ... 594 // 2147483647 -> 4294967294 595 // -2147483648 -> 4294967295 596 // 597 // >> encode >> 598 // << decode << 599 600 inline uint32 WireFormatLite::ZigZagEncode32(int32 n) { 601 // Note: the right-shift must be arithmetic 602 return (n << 1) ^ (n >> 31); 603 } 604 605 inline int32 WireFormatLite::ZigZagDecode32(uint32 n) { 606 return (n >> 1) ^ -static_cast<int32>(n & 1); 607 } 608 609 inline uint64 WireFormatLite::ZigZagEncode64(int64 n) { 610 // Note: the right-shift must be arithmetic 611 return (n << 1) ^ (n >> 63); 612 } 613 614 inline int64 WireFormatLite::ZigZagDecode64(uint64 n) { 615 return (n >> 1) ^ -static_cast<int64>(n & 1); 616 } 617 618 } // namespace internal 619 } // namespace protobuf 620 621 } // namespace google 622 #endif // GOOGLE_PROTOBUF_WIRE_FORMAT_LITE_H__ 623
