Line data Source code
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
137 : static inline WireFormatLite::WireType WireTypeForFieldType(
138 : WireFormatLite::FieldType type) {
139 3557 : 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 71 : FieldSkipper() {}
549 0 : 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 0 : : unknown_fields_(unknown_fields) {}
570 0 : 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 2 : return kFieldTypeToCppTypeMap[type];
587 : }
588 :
589 4096568 : inline uint32 WireFormatLite::MakeTag(int field_number, WireType type) {
590 4101090 : return GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(field_number, type);
591 : }
592 :
593 0 : inline WireFormatLite::WireType WireFormatLite::GetTagWireType(uint32 tag) {
594 308 : return static_cast<WireType>(tag & kTagTypeMask);
595 : }
596 :
597 4069208 : inline int WireFormatLite::GetTagFieldNumber(uint32 tag) {
598 4091885 : 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 18760 : field_number << kTagTypeBits);
605 9380 : if (type == TYPE_GROUP) {
606 : // Groups have both a start and an end tag.
607 88 : return result * 2;
608 : } else {
609 : return result;
610 : }
611 : }
612 :
613 0 : inline uint32 WireFormatLite::EncodeFloat(float value) {
614 : union {float f; uint32 i;};
615 3 : f = value;
616 3 : return i;
617 : }
618 :
619 0 : inline float WireFormatLite::DecodeFloat(uint32 value) {
620 : union {float f; uint32 i;};
621 0 : i = value;
622 0 : return f;
623 : }
624 :
625 135 : inline uint64 WireFormatLite::EncodeDouble(double value) {
626 : union {double f; uint64 i;};
627 138 : f = value;
628 138 : return i;
629 : }
630 :
631 135 : inline double WireFormatLite::DecodeDouble(uint64 value) {
632 : union {double f; uint64 i;};
633 135 : i = value;
634 135 : 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 0 : inline uint32 WireFormatLite::ZigZagEncode32(int32 n) {
662 : // Note: the right-shift must be arithmetic
663 2 : return (static_cast<uint32>(n) << 1) ^ (n >> 31);
664 : }
665 :
666 0 : inline int32 WireFormatLite::ZigZagDecode32(uint32 n) {
667 0 : return (n >> 1) ^ -static_cast<int32>(n & 1);
668 : }
669 :
670 0 : inline uint64 WireFormatLite::ZigZagEncode64(int64 n) {
671 : // Note: the right-shift must be arithmetic
672 3 : return (static_cast<uint64>(n) << 1) ^ (n >> 63);
673 : }
674 :
675 0 : inline int64 WireFormatLite::ZigZagDecode64(uint64 n) {
676 0 : 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 239657 : inline bool WireFormatLite::ReadString(io::CodedInputStream* input,
683 : string* value) {
684 254742 : 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__
|
