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> 254 static inline bool ReadPrimitive(input, CType* value) INL; 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> 260 static inline bool ReadRepeatedPrimitive(int tag_size, 261 uint32 tag, 262 input, 263 RepeatedField<CType>* value) INL; 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> 279 static inline const uint8* ReadPrimitiveFromArray(const uint8* buffer, 280 CType* value) INL; 281 282 // Reads a primitive packed field. 283 // 284 // This is only implemented for packable types. 285 template <typename CType, enum FieldType DeclaredType> 286 static inline bool ReadPackedPrimitive(input, 287 RepeatedField<CType>* value) INL; 288 289 // Identical to ReadPackedPrimitive, except will not inline the 290 // implementation. 291 template <typename CType, enum FieldType DeclaredType> 292 static bool ReadPackedPrimitiveNoInline(input, RepeatedField<CType>* value); 293 294 // Read a packed enum field. Values for which is_valid() returns false are 295 // dropped. 296 static bool ReadPackedEnumNoInline(input, 297 bool (*is_valid)(int), 298 RepeatedField<int>* value); 299 300 static bool ReadString(input, string* value); 301 static bool ReadBytes (input, string* value); 302 303 static inline bool ReadGroup (field_number, input, MessageLite* value); 304 static inline bool ReadMessage(input, MessageLite* value); 305 306 // Like above, but de-virtualize the call to MergePartialFromCodedStream(). 307 // The pointer must point at an instance of MessageType, *not* a subclass (or 308 // the subclass must not override MergePartialFromCodedStream()). 309 template<typename MessageType> 310 static inline bool ReadGroupNoVirtual(field_number, input, 311 MessageType* value); 312 template<typename MessageType> 313 static inline bool ReadMessageNoVirtual(input, MessageType* value); 314 315 // Write a tag. The Write*() functions typically include the tag, so 316 // normally there's no need to call this unless using the Write*NoTag() 317 // variants. 318 static inline void WriteTag(field_number, WireType type, output) INL; 319 320 // Write fields, without tags. 321 static inline void WriteInt32NoTag (int32 value, output) INL; 322 static inline void WriteInt64NoTag (int64 value, output) INL; 323 static inline void WriteUInt32NoTag (uint32 value, output) INL; 324 static inline void WriteUInt64NoTag (uint64 value, output) INL; 325 static inline void WriteSInt32NoTag (int32 value, output) INL; 326 static inline void WriteSInt64NoTag (int64 value, output) INL; 327 static inline void WriteFixed32NoTag (uint32 value, output) INL; 328 static inline void WriteFixed64NoTag (uint64 value, output) INL; 329 static inline void WriteSFixed32NoTag(int32 value, output) INL; 330 static inline void WriteSFixed64NoTag(int64 value, output) INL; 331 static inline void WriteFloatNoTag (float value, output) INL; 332 static inline void WriteDoubleNoTag (double value, output) INL; 333 static inline void WriteBoolNoTag (bool value, output) INL; 334 static inline void WriteEnumNoTag (int value, output) INL; 335 336 // Write fields, including tags. 337 static void WriteInt32 (field_number, int32 value, output); 338 static void WriteInt64 (field_number, int64 value, output); 339 static void WriteUInt32 (field_number, uint32 value, output); 340 static void WriteUInt64 (field_number, uint64 value, output); 341 static void WriteSInt32 (field_number, int32 value, output); 342 static void WriteSInt64 (field_number, int64 value, output); 343 static void WriteFixed32 (field_number, uint32 value, output); 344 static void WriteFixed64 (field_number, uint64 value, output); 345 static void WriteSFixed32(field_number, int32 value, output); 346 static void WriteSFixed64(field_number, int64 value, output); 347 static void WriteFloat (field_number, float value, output); 348 static void WriteDouble (field_number, double value, output); 349 static void WriteBool (field_number, bool value, output); 350 static void WriteEnum (field_number, int value, output); 351 352 static void WriteString(field_number, const string& value, output); 353 static void WriteBytes (field_number, const string& value, output); 354 static void WriteStringMaybeAliased( 355 field_number, const string& value, output); 356 static void WriteBytesMaybeAliased( 357 field_number, const string& value, output); 358 359 static void WriteGroup( 360 field_number, const MessageLite& value, output); 361 static void WriteMessage( 362 field_number, const MessageLite& value, output); 363 // Like above, but these will check if the output stream has enough 364 // space to write directly to a flat array. 365 static void WriteGroupMaybeToArray( 366 field_number, const MessageLite& value, output); 367 static void WriteMessageMaybeToArray( 368 field_number, const MessageLite& value, output); 369 370 // Like above, but de-virtualize the call to SerializeWithCachedSizes(). The 371 // pointer must point at an instance of MessageType, *not* a subclass (or 372 // the subclass must not override SerializeWithCachedSizes()). 373 template<typename MessageType> 374 static inline void WriteGroupNoVirtual( 375 field_number, const MessageType& value, output); 376 template<typename MessageType> 377 static inline void WriteMessageNoVirtual( 378 field_number, const MessageType& value, output); 379 380 #undef output 381 #define output uint8* target 382 383 // Like above, but use only *ToArray methods of CodedOutputStream. 384 static inline uint8* WriteTagToArray(field_number, WireType type, output) INL; 385 386 // Write fields, without tags. 387 static inline uint8* WriteInt32NoTagToArray (int32 value, output) INL; 388 static inline uint8* WriteInt64NoTagToArray (int64 value, output) INL; 389 static inline uint8* WriteUInt32NoTagToArray (uint32 value, output) INL; 390 static inline uint8* WriteUInt64NoTagToArray (uint64 value, output) INL; 391 static inline uint8* WriteSInt32NoTagToArray (int32 value, output) INL; 392 static inline uint8* WriteSInt64NoTagToArray (int64 value, output) INL; 393 static inline uint8* WriteFixed32NoTagToArray (uint32 value, output) INL; 394 static inline uint8* WriteFixed64NoTagToArray (uint64 value, output) INL; 395 static inline uint8* WriteSFixed32NoTagToArray(int32 value, output) INL; 396 static inline uint8* WriteSFixed64NoTagToArray(int64 value, output) INL; 397 static inline uint8* WriteFloatNoTagToArray (float value, output) INL; 398 static inline uint8* WriteDoubleNoTagToArray (double value, output) INL; 399 static inline uint8* WriteBoolNoTagToArray (bool value, output) INL; 400 static inline uint8* WriteEnumNoTagToArray (int value, output) INL; 401 402 // Write fields, including tags. 403 static inline uint8* WriteInt32ToArray( 404 field_number, int32 value, output) INL; 405 static inline uint8* WriteInt64ToArray( 406 field_number, int64 value, output) INL; 407 static inline uint8* WriteUInt32ToArray( 408 field_number, uint32 value, output) INL; 409 static inline uint8* WriteUInt64ToArray( 410 field_number, uint64 value, output) INL; 411 static inline uint8* WriteSInt32ToArray( 412 field_number, int32 value, output) INL; 413 static inline uint8* WriteSInt64ToArray( 414 field_number, int64 value, output) INL; 415 static inline uint8* WriteFixed32ToArray( 416 field_number, uint32 value, output) INL; 417 static inline uint8* WriteFixed64ToArray( 418 field_number, uint64 value, output) INL; 419 static inline uint8* WriteSFixed32ToArray( 420 field_number, int32 value, output) INL; 421 static inline uint8* WriteSFixed64ToArray( 422 field_number, int64 value, output) INL; 423 static inline uint8* WriteFloatToArray( 424 field_number, float value, output) INL; 425 static inline uint8* WriteDoubleToArray( 426 field_number, double value, output) INL; 427 static inline uint8* WriteBoolToArray( 428 field_number, bool value, output) INL; 429 static inline uint8* WriteEnumToArray( 430 field_number, int value, output) INL; 431 432 static inline uint8* WriteStringToArray( 433 field_number, const string& value, output) INL; 434 static inline uint8* WriteBytesToArray( 435 field_number, const string& value, output) INL; 436 437 static inline uint8* WriteGroupToArray( 438 field_number, const MessageLite& value, output) INL; 439 static inline uint8* WriteMessageToArray( 440 field_number, const MessageLite& value, output) INL; 441 442 // Like above, but de-virtualize the call to SerializeWithCachedSizes(). The 443 // pointer must point at an instance of MessageType, *not* a subclass (or 444 // the subclass must not override SerializeWithCachedSizes()). 445 template<typename MessageType> 446 static inline uint8* WriteGroupNoVirtualToArray( 447 field_number, const MessageType& value, output) INL; 448 template<typename MessageType> 449 static inline uint8* WriteMessageNoVirtualToArray( 450 field_number, const MessageType& value, output) INL; 451 452 #undef output 453 #undef input 454 #undef INL 455 456 #undef field_number 457 458 // Compute the byte size of a field. The XxSize() functions do NOT include 459 // the tag, so you must also call TagSize(). (This is because, for repeated 460 // fields, you should only call TagSize() once and multiply it by the element 461 // count, but you may have to call XxSize() for each individual element.) 462 static inline int Int32Size ( int32 value); 463 static inline int Int64Size ( int64 value); 464 static inline int UInt32Size (uint32 value); 465 static inline int UInt64Size (uint64 value); 466 static inline int SInt32Size ( int32 value); 467 static inline int SInt64Size ( int64 value); 468 static inline int EnumSize ( int value); 469 470 // These types always have the same size. 471 static const int kFixed32Size = 4; 472 static const int kFixed64Size = 8; 473 static const int kSFixed32Size = 4; 474 static const int kSFixed64Size = 8; 475 static const int kFloatSize = 4; 476 static const int kDoubleSize = 8; 477 static const int kBoolSize = 1; 478 479 static inline int StringSize(const string& value); 480 static inline int BytesSize (const string& value); 481 482 static inline int GroupSize (const MessageLite& value); 483 static inline int MessageSize(const MessageLite& value); 484 485 // Like above, but de-virtualize the call to ByteSize(). The 486 // pointer must point at an instance of MessageType, *not* a subclass (or 487 // the subclass must not override ByteSize()). 488 template<typename MessageType> 489 static inline int GroupSizeNoVirtual (const MessageType& value); 490 template<typename MessageType> 491 static inline int MessageSizeNoVirtual(const MessageType& value); 492 493 // Given the length of data, calculate the byte size of the data on the 494 // wire if we encode the data as a length delimited field. 495 static inline int LengthDelimitedSize(int length); 496 497 private: 498 // A helper method for the repeated primitive reader. This method has 499 // optimizations for primitive types that have fixed size on the wire, and 500 // can be read using potentially faster paths. 501 template <typename CType, enum FieldType DeclaredType> 502 static inline bool ReadRepeatedFixedSizePrimitive( 503 int tag_size, 504 uint32 tag, 505 google::protobuf::io::CodedInputStream* input, 506 RepeatedField<CType>* value) GOOGLE_ATTRIBUTE_ALWAYS_INLINE; 507 508 // Like ReadRepeatedFixedSizePrimitive but for packed primitive fields. 509 template <typename CType, enum FieldType DeclaredType> 510 static inline bool ReadPackedFixedSizePrimitive( 511 google::protobuf::io::CodedInputStream* input, 512 RepeatedField<CType>* value) GOOGLE_ATTRIBUTE_ALWAYS_INLINE; 513 514 static const CppType kFieldTypeToCppTypeMap[]; 515 static const WireFormatLite::WireType kWireTypeForFieldType[]; 516 517 GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(WireFormatLite); 518 }; 519 520 // A class which deals with unknown values. The default implementation just 521 // discards them. WireFormat defines a subclass which writes to an 522 // UnknownFieldSet. This class is used by ExtensionSet::ParseField(), since 523 // ExtensionSet is part of the lite library but UnknownFieldSet is not. 524 class LIBPROTOBUF_EXPORT FieldSkipper { 525 public: 526 FieldSkipper() {} 527 virtual ~FieldSkipper() {} 528 529 // Skip a field whose tag has already been consumed. 530 virtual bool SkipField(io::CodedInputStream* input, uint32 tag); 531 532 // Skip an entire message or group, up to an end-group tag (which is consumed) 533 // or end-of-stream. 534 virtual bool SkipMessage(io::CodedInputStream* input); 535 536 // Deal with an already-parsed unrecognized enum value. The default 537 // implementation does nothing, but the UnknownFieldSet-based implementation 538 // saves it as an unknown varint. 539 virtual void SkipUnknownEnum(int field_number, int value); 540 }; 541 542 // Subclass of FieldSkipper which saves skipped fields to a CodedOutputStream. 543 544 class LIBPROTOBUF_EXPORT CodedOutputStreamFieldSkipper : public FieldSkipper { 545 public: 546 explicit CodedOutputStreamFieldSkipper(io::CodedOutputStream* unknown_fields) 547 : unknown_fields_(unknown_fields) {} 548 virtual ~CodedOutputStreamFieldSkipper() {} 549 550 // implements FieldSkipper ----------------------------------------- 551 virtual bool SkipField(io::CodedInputStream* input, uint32 tag); 552 virtual bool SkipMessage(io::CodedInputStream* input); 553 virtual void SkipUnknownEnum(int field_number, int value); 554 555 protected: 556 io::CodedOutputStream* unknown_fields_; 557 }; 558 559 560 // inline methods ==================================================== 561 562 inline WireFormatLite::CppType 563 WireFormatLite::FieldTypeToCppType(FieldType type) { 564 return kFieldTypeToCppTypeMap[type]; 565 } 566 567 inline uint32 WireFormatLite::MakeTag(int field_number, WireType type) { 568 return GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(field_number, type); 569 } 570 571 inline WireFormatLite::WireType WireFormatLite::GetTagWireType(uint32 tag) { 572 return static_cast<WireType>(tag & kTagTypeMask); 573 } 574 575 inline int WireFormatLite::GetTagFieldNumber(uint32 tag) { 576 return static_cast<int>(tag >> kTagTypeBits); 577 } 578 579 inline int WireFormatLite::TagSize(int field_number, 580 WireFormatLite::FieldType type) { 581 int result = io::CodedOutputStream::VarintSize32( 582 field_number << kTagTypeBits); 583 if (type == TYPE_GROUP) { 584 // Groups have both a start and an end tag. 585 return result * 2; 586 } else { 587 return result; 588 } 589 } 590 591 inline uint32 WireFormatLite::EncodeFloat(float value) { 592 union {float f; uint32 i;}; 593 f = value; 594 return i; 595 } 596 597 inline float WireFormatLite::DecodeFloat(uint32 value) { 598 union {float f; uint32 i;}; 599 i = value; 600 return f; 601 } 602 603 inline uint64 WireFormatLite::EncodeDouble(double value) { 604 union {double f; uint64 i;}; 605 f = value; 606 return i; 607 } 608 609 inline double WireFormatLite::DecodeDouble(uint64 value) { 610 union {double f; uint64 i;}; 611 i = value; 612 return f; 613 } 614 615 // ZigZag Transform: Encodes signed integers so that they can be 616 // effectively used with varint encoding. 617 // 618 // varint operates on unsigned integers, encoding smaller numbers into 619 // fewer bytes. If you try to use it on a signed integer, it will treat 620 // this number as a very large unsigned integer, which means that even 621 // small signed numbers like -1 will take the maximum number of bytes 622 // (10) to encode. ZigZagEncode() maps signed integers to unsigned 623 // in such a way that those with a small absolute value will have smaller 624 // encoded values, making them appropriate for encoding using varint. 625 // 626 // int32 -> uint32 627 // ------------------------- 628 // 0 -> 0 629 // -1 -> 1 630 // 1 -> 2 631 // -2 -> 3 632 // ... -> ... 633 // 2147483647 -> 4294967294 634 // -2147483648 -> 4294967295 635 // 636 // >> encode >> 637 // << decode << 638 639 inline uint32 WireFormatLite::ZigZagEncode32(int32 n) { 640 // Note: the right-shift must be arithmetic 641 return (n << 1) ^ (n >> 31); 642 } 643 644 inline int32 WireFormatLite::ZigZagDecode32(uint32 n) { 645 return (n >> 1) ^ -static_cast<int32>(n & 1); 646 } 647 648 inline uint64 WireFormatLite::ZigZagEncode64(int64 n) { 649 // Note: the right-shift must be arithmetic 650 return (n << 1) ^ (n >> 63); 651 } 652 653 inline int64 WireFormatLite::ZigZagDecode64(uint64 n) { 654 return (n >> 1) ^ -static_cast<int64>(n & 1); 655 } 656 657 } // namespace internal 658 } // namespace protobuf 659 660 } // namespace google 661 #endif // GOOGLE_PROTOBUF_WIRE_FORMAT_LITE_H__ 662
