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@google.com (Kenton Varda)
32 // atenasio@google.com (Chris Atenasio) (ZigZag transform)
33 // wink@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
WireTypeForFieldType(WireFormatLite::FieldType type)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:
FieldSkipper()548 FieldSkipper() {}
~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:
CodedOutputStreamFieldSkipper(io::CodedOutputStream * unknown_fields)568 explicit CodedOutputStreamFieldSkipper(io::CodedOutputStream* unknown_fields)
569 : unknown_fields_(unknown_fields) {}
~CodedOutputStreamFieldSkipper()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
FieldTypeToCppType(FieldType type)585 WireFormatLite::FieldTypeToCppType(FieldType type) {
586 return kFieldTypeToCppTypeMap[type];
587 }
588
MakeTag(int field_number,WireType type)589 inline uint32 WireFormatLite::MakeTag(int field_number, WireType type) {
590 return GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(field_number, type);
591 }
592
GetTagWireType(uint32 tag)593 inline WireFormatLite::WireType WireFormatLite::GetTagWireType(uint32 tag) {
594 return static_cast<WireType>(tag & kTagTypeMask);
595 }
596
GetTagFieldNumber(uint32 tag)597 inline int WireFormatLite::GetTagFieldNumber(uint32 tag) {
598 return static_cast<int>(tag >> kTagTypeBits);
599 }
600
TagSize(int field_number,WireFormatLite::FieldType type)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
EncodeFloat(float value)613 inline uint32 WireFormatLite::EncodeFloat(float value) {
614 union {float f; uint32 i;};
615 f = value;
616 return i;
617 }
618
DecodeFloat(uint32 value)619 inline float WireFormatLite::DecodeFloat(uint32 value) {
620 union {float f; uint32 i;};
621 i = value;
622 return f;
623 }
624
EncodeDouble(double value)625 inline uint64 WireFormatLite::EncodeDouble(double value) {
626 union {double f; uint64 i;};
627 f = value;
628 return i;
629 }
630
DecodeDouble(uint64 value)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
ZigZagEncode32(int32 n)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
ZigZagDecode32(uint32 n)666 inline int32 WireFormatLite::ZigZagDecode32(uint32 n) {
667 return (n >> 1) ^ -static_cast<int32>(n & 1);
668 }
669
ZigZagEncode64(int64 n)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
ZigZagDecode64(uint64 n)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
ReadString(io::CodedInputStream * input,string * value)682 inline bool WireFormatLite::ReadString(io::CodedInputStream* input,
683 string* value) {
684 return ReadBytes(input, value);
685 }
686
ReadString(io::CodedInputStream * input,string ** p)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