kenton@google.com | 80b1d62 | 2009-07-29 01:13:20 +0000 | [diff] [blame] | 1 | // Protocol Buffers - Google's data interchange format |
| 2 | // Copyright 2008 Google Inc. All rights reserved. |
Feng Xiao | e428862 | 2014-10-01 16:26:23 -0700 | [diff] [blame] | 3 | // https://developers.google.com/protocol-buffers/ |
kenton@google.com | 80b1d62 | 2009-07-29 01:13:20 +0000 | [diff] [blame] | 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> |
xiaofeng@google.com | b55a20f | 2012-09-22 02:40:50 +0000 | [diff] [blame] | 44 | #include <google/protobuf/stubs/common.h> |
kenton@google.com | 80b1d62 | 2009-07-29 01:13:20 +0000 | [diff] [blame] | 45 | #include <google/protobuf/message_lite.h> |
xiaofeng@google.com | b55a20f | 2012-09-22 02:40:50 +0000 | [diff] [blame] | 46 | #include <google/protobuf/io/coded_stream.h> // for CodedOutputStream::Varint32Size |
kenton@google.com | 80b1d62 | 2009-07-29 01:13:20 +0000 | [diff] [blame] | 47 | |
| 48 | namespace google { |
| 49 | |
| 50 | namespace protobuf { |
kenton@google.com | fccb146 | 2009-12-18 02:11:36 +0000 | [diff] [blame] | 51 | template <typename T> class RepeatedField; // repeated_field.h |
kenton@google.com | 80b1d62 | 2009-07-29 01:13:20 +0000 | [diff] [blame] | 52 | } |
| 53 | |
| 54 | namespace protobuf { |
| 55 | namespace internal { |
| 56 | |
kenton@google.com | fccb146 | 2009-12-18 02:11:36 +0000 | [diff] [blame] | 57 | class StringPieceField; |
| 58 | |
kenton@google.com | 80b1d62 | 2009-07-29 01:13:20 +0000 | [diff] [blame] | 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 | |
jieluo@google.com | 4de8f55 | 2014-07-18 00:47:59 +0000 | [diff] [blame] | 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 | |
kenton@google.com | 80b1d62 | 2009-07-29 01:13:20 +0000 | [diff] [blame] | 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 | |
jieluo@google.com | 4de8f55 | 2014-07-18 00:47:59 +0000 | [diff] [blame] | 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 | |
kenton@google.com | 80b1d62 | 2009-07-29 01:13:20 +0000 | [diff] [blame] | 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 | // } |
kenton@google.com | fccb146 | 2009-12-18 02:11:36 +0000 | [diff] [blame] | 198 | static const int kMessageSetItemNumber = 1; |
| 199 | static const int kMessageSetTypeIdNumber = 2; |
| 200 | static const int kMessageSetMessageNumber = 3; |
kenton@google.com | 80b1d62 | 2009-07-29 01:13:20 +0000 | [diff] [blame] | 201 | static const int kMessageSetItemStartTag = |
kenton@google.com | fccb146 | 2009-12-18 02:11:36 +0000 | [diff] [blame] | 202 | GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(kMessageSetItemNumber, |
| 203 | WireFormatLite::WIRETYPE_START_GROUP); |
kenton@google.com | 80b1d62 | 2009-07-29 01:13:20 +0000 | [diff] [blame] | 204 | static const int kMessageSetItemEndTag = |
kenton@google.com | fccb146 | 2009-12-18 02:11:36 +0000 | [diff] [blame] | 205 | GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(kMessageSetItemNumber, |
| 206 | WireFormatLite::WIRETYPE_END_GROUP); |
kenton@google.com | 80b1d62 | 2009-07-29 01:13:20 +0000 | [diff] [blame] | 207 | static const int kMessageSetTypeIdTag = |
kenton@google.com | fccb146 | 2009-12-18 02:11:36 +0000 | [diff] [blame] | 208 | GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(kMessageSetTypeIdNumber, |
| 209 | WireFormatLite::WIRETYPE_VARINT); |
kenton@google.com | 80b1d62 | 2009-07-29 01:13:20 +0000 | [diff] [blame] | 210 | static const int kMessageSetMessageTag = |
kenton@google.com | fccb146 | 2009-12-18 02:11:36 +0000 | [diff] [blame] | 211 | GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(kMessageSetMessageNumber, |
| 212 | WireFormatLite::WIRETYPE_LENGTH_DELIMITED); |
kenton@google.com | 80b1d62 | 2009-07-29 01:13:20 +0000 | [diff] [blame] | 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 |
Feng Xiao | 3b8dadf | 2014-10-08 17:32:53 -0700 | [diff] [blame] | 242 | #define input io::CodedInputStream* input_arg |
| 243 | #define output io::CodedOutputStream* output_arg |
| 244 | #define field_number int field_number_arg |
kenton@google.com | 80b1d62 | 2009-07-29 01:13:20 +0000 | [diff] [blame] | 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. |
kenton@google.com | 80b1d62 | 2009-07-29 01:13:20 +0000 | [diff] [blame] | 249 | |
kenton@google.com | fccb146 | 2009-12-18 02:11:36 +0000 | [diff] [blame] | 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 | |
Jisi Liu | 885b612 | 2015-02-28 14:51:22 -0800 | [diff] [blame^] | 294 | // Read a packed enum field. If the is_valid function is not NULL, values for |
| 295 | // which is_valid(value) returns false are silently dropped. |
kenton@google.com | fccb146 | 2009-12-18 02:11:36 +0000 | [diff] [blame] | 296 | static bool ReadPackedEnumNoInline(input, |
| 297 | bool (*is_valid)(int), |
Jisi Liu | 885b612 | 2015-02-28 14:51:22 -0800 | [diff] [blame^] | 298 | RepeatedField<int>* values); |
| 299 | |
| 300 | // Read a packed enum field. If the is_valid function is not NULL, values for |
| 301 | // which is_valid(value) returns false are appended to unknown_fields_stream. |
| 302 | static bool ReadPackedEnumPreserveUnknowns( |
| 303 | input, |
| 304 | field_number, |
| 305 | bool (*is_valid)(int), |
| 306 | io::CodedOutputStream* unknown_fields_stream, |
| 307 | RepeatedField<int>* values); |
kenton@google.com | fccb146 | 2009-12-18 02:11:36 +0000 | [diff] [blame] | 308 | |
Feng Xiao | 6ef984a | 2014-11-10 17:34:54 -0800 | [diff] [blame] | 309 | // Read a string. ReadString(..., string* value) requires an existing string. |
| 310 | static inline bool ReadString(input, string* value); |
| 311 | // ReadString(..., string** p) is internal-only, and should only be called |
| 312 | // from generated code. It starts by setting *p to "new string" |
| 313 | // if *p == &GetEmptyStringAlreadyInited(). It then invokes |
| 314 | // ReadString(input, *p). This is useful for reducing code size. |
| 315 | static inline bool ReadString(input, string** p); |
| 316 | // Analogous to ReadString(). |
| 317 | static bool ReadBytes(input, string* value); |
| 318 | static bool ReadBytes(input, string** p); |
| 319 | |
kenton@google.com | 80b1d62 | 2009-07-29 01:13:20 +0000 | [diff] [blame] | 320 | |
| 321 | static inline bool ReadGroup (field_number, input, MessageLite* value); |
| 322 | static inline bool ReadMessage(input, MessageLite* value); |
| 323 | |
| 324 | // Like above, but de-virtualize the call to MergePartialFromCodedStream(). |
| 325 | // The pointer must point at an instance of MessageType, *not* a subclass (or |
| 326 | // the subclass must not override MergePartialFromCodedStream()). |
| 327 | template<typename MessageType> |
| 328 | static inline bool ReadGroupNoVirtual(field_number, input, |
| 329 | MessageType* value); |
| 330 | template<typename MessageType> |
| 331 | static inline bool ReadMessageNoVirtual(input, MessageType* value); |
| 332 | |
| 333 | // Write a tag. The Write*() functions typically include the tag, so |
| 334 | // normally there's no need to call this unless using the Write*NoTag() |
| 335 | // variants. |
| 336 | static inline void WriteTag(field_number, WireType type, output) INL; |
| 337 | |
| 338 | // Write fields, without tags. |
| 339 | static inline void WriteInt32NoTag (int32 value, output) INL; |
| 340 | static inline void WriteInt64NoTag (int64 value, output) INL; |
| 341 | static inline void WriteUInt32NoTag (uint32 value, output) INL; |
| 342 | static inline void WriteUInt64NoTag (uint64 value, output) INL; |
| 343 | static inline void WriteSInt32NoTag (int32 value, output) INL; |
| 344 | static inline void WriteSInt64NoTag (int64 value, output) INL; |
| 345 | static inline void WriteFixed32NoTag (uint32 value, output) INL; |
| 346 | static inline void WriteFixed64NoTag (uint64 value, output) INL; |
| 347 | static inline void WriteSFixed32NoTag(int32 value, output) INL; |
| 348 | static inline void WriteSFixed64NoTag(int64 value, output) INL; |
| 349 | static inline void WriteFloatNoTag (float value, output) INL; |
| 350 | static inline void WriteDoubleNoTag (double value, output) INL; |
| 351 | static inline void WriteBoolNoTag (bool value, output) INL; |
| 352 | static inline void WriteEnumNoTag (int value, output) INL; |
| 353 | |
| 354 | // Write fields, including tags. |
kenton@google.com | fccb146 | 2009-12-18 02:11:36 +0000 | [diff] [blame] | 355 | static void WriteInt32 (field_number, int32 value, output); |
| 356 | static void WriteInt64 (field_number, int64 value, output); |
| 357 | static void WriteUInt32 (field_number, uint32 value, output); |
| 358 | static void WriteUInt64 (field_number, uint64 value, output); |
| 359 | static void WriteSInt32 (field_number, int32 value, output); |
| 360 | static void WriteSInt64 (field_number, int64 value, output); |
| 361 | static void WriteFixed32 (field_number, uint32 value, output); |
| 362 | static void WriteFixed64 (field_number, uint64 value, output); |
| 363 | static void WriteSFixed32(field_number, int32 value, output); |
| 364 | static void WriteSFixed64(field_number, int64 value, output); |
| 365 | static void WriteFloat (field_number, float value, output); |
| 366 | static void WriteDouble (field_number, double value, output); |
| 367 | static void WriteBool (field_number, bool value, output); |
| 368 | static void WriteEnum (field_number, int value, output); |
kenton@google.com | 80b1d62 | 2009-07-29 01:13:20 +0000 | [diff] [blame] | 369 | |
kenton@google.com | fccb146 | 2009-12-18 02:11:36 +0000 | [diff] [blame] | 370 | static void WriteString(field_number, const string& value, output); |
| 371 | static void WriteBytes (field_number, const string& value, output); |
jieluo@google.com | 4de8f55 | 2014-07-18 00:47:59 +0000 | [diff] [blame] | 372 | static void WriteStringMaybeAliased( |
| 373 | field_number, const string& value, output); |
| 374 | static void WriteBytesMaybeAliased( |
| 375 | field_number, const string& value, output); |
kenton@google.com | 80b1d62 | 2009-07-29 01:13:20 +0000 | [diff] [blame] | 376 | |
kenton@google.com | fccb146 | 2009-12-18 02:11:36 +0000 | [diff] [blame] | 377 | static void WriteGroup( |
| 378 | field_number, const MessageLite& value, output); |
| 379 | static void WriteMessage( |
| 380 | field_number, const MessageLite& value, output); |
| 381 | // Like above, but these will check if the output stream has enough |
| 382 | // space to write directly to a flat array. |
| 383 | static void WriteGroupMaybeToArray( |
| 384 | field_number, const MessageLite& value, output); |
| 385 | static void WriteMessageMaybeToArray( |
| 386 | field_number, const MessageLite& value, output); |
kenton@google.com | 80b1d62 | 2009-07-29 01:13:20 +0000 | [diff] [blame] | 387 | |
| 388 | // Like above, but de-virtualize the call to SerializeWithCachedSizes(). The |
| 389 | // pointer must point at an instance of MessageType, *not* a subclass (or |
| 390 | // the subclass must not override SerializeWithCachedSizes()). |
| 391 | template<typename MessageType> |
| 392 | static inline void WriteGroupNoVirtual( |
kenton@google.com | fccb146 | 2009-12-18 02:11:36 +0000 | [diff] [blame] | 393 | field_number, const MessageType& value, output); |
kenton@google.com | 80b1d62 | 2009-07-29 01:13:20 +0000 | [diff] [blame] | 394 | template<typename MessageType> |
| 395 | static inline void WriteMessageNoVirtual( |
kenton@google.com | fccb146 | 2009-12-18 02:11:36 +0000 | [diff] [blame] | 396 | field_number, const MessageType& value, output); |
kenton@google.com | 80b1d62 | 2009-07-29 01:13:20 +0000 | [diff] [blame] | 397 | |
| 398 | #undef output |
| 399 | #define output uint8* target |
| 400 | |
| 401 | // Like above, but use only *ToArray methods of CodedOutputStream. |
| 402 | static inline uint8* WriteTagToArray(field_number, WireType type, output) INL; |
| 403 | |
| 404 | // Write fields, without tags. |
| 405 | static inline uint8* WriteInt32NoTagToArray (int32 value, output) INL; |
| 406 | static inline uint8* WriteInt64NoTagToArray (int64 value, output) INL; |
| 407 | static inline uint8* WriteUInt32NoTagToArray (uint32 value, output) INL; |
| 408 | static inline uint8* WriteUInt64NoTagToArray (uint64 value, output) INL; |
| 409 | static inline uint8* WriteSInt32NoTagToArray (int32 value, output) INL; |
| 410 | static inline uint8* WriteSInt64NoTagToArray (int64 value, output) INL; |
| 411 | static inline uint8* WriteFixed32NoTagToArray (uint32 value, output) INL; |
| 412 | static inline uint8* WriteFixed64NoTagToArray (uint64 value, output) INL; |
| 413 | static inline uint8* WriteSFixed32NoTagToArray(int32 value, output) INL; |
| 414 | static inline uint8* WriteSFixed64NoTagToArray(int64 value, output) INL; |
| 415 | static inline uint8* WriteFloatNoTagToArray (float value, output) INL; |
| 416 | static inline uint8* WriteDoubleNoTagToArray (double value, output) INL; |
| 417 | static inline uint8* WriteBoolNoTagToArray (bool value, output) INL; |
| 418 | static inline uint8* WriteEnumNoTagToArray (int value, output) INL; |
| 419 | |
| 420 | // Write fields, including tags. |
| 421 | static inline uint8* WriteInt32ToArray( |
| 422 | field_number, int32 value, output) INL; |
| 423 | static inline uint8* WriteInt64ToArray( |
| 424 | field_number, int64 value, output) INL; |
| 425 | static inline uint8* WriteUInt32ToArray( |
| 426 | field_number, uint32 value, output) INL; |
| 427 | static inline uint8* WriteUInt64ToArray( |
| 428 | field_number, uint64 value, output) INL; |
| 429 | static inline uint8* WriteSInt32ToArray( |
| 430 | field_number, int32 value, output) INL; |
| 431 | static inline uint8* WriteSInt64ToArray( |
| 432 | field_number, int64 value, output) INL; |
| 433 | static inline uint8* WriteFixed32ToArray( |
| 434 | field_number, uint32 value, output) INL; |
| 435 | static inline uint8* WriteFixed64ToArray( |
| 436 | field_number, uint64 value, output) INL; |
| 437 | static inline uint8* WriteSFixed32ToArray( |
| 438 | field_number, int32 value, output) INL; |
| 439 | static inline uint8* WriteSFixed64ToArray( |
| 440 | field_number, int64 value, output) INL; |
| 441 | static inline uint8* WriteFloatToArray( |
| 442 | field_number, float value, output) INL; |
| 443 | static inline uint8* WriteDoubleToArray( |
| 444 | field_number, double value, output) INL; |
| 445 | static inline uint8* WriteBoolToArray( |
| 446 | field_number, bool value, output) INL; |
| 447 | static inline uint8* WriteEnumToArray( |
| 448 | field_number, int value, output) INL; |
| 449 | |
| 450 | static inline uint8* WriteStringToArray( |
| 451 | field_number, const string& value, output) INL; |
| 452 | static inline uint8* WriteBytesToArray( |
| 453 | field_number, const string& value, output) INL; |
| 454 | |
| 455 | static inline uint8* WriteGroupToArray( |
| 456 | field_number, const MessageLite& value, output) INL; |
| 457 | static inline uint8* WriteMessageToArray( |
| 458 | field_number, const MessageLite& value, output) INL; |
| 459 | |
| 460 | // Like above, but de-virtualize the call to SerializeWithCachedSizes(). The |
| 461 | // pointer must point at an instance of MessageType, *not* a subclass (or |
| 462 | // the subclass must not override SerializeWithCachedSizes()). |
| 463 | template<typename MessageType> |
| 464 | static inline uint8* WriteGroupNoVirtualToArray( |
| 465 | field_number, const MessageType& value, output) INL; |
| 466 | template<typename MessageType> |
| 467 | static inline uint8* WriteMessageNoVirtualToArray( |
| 468 | field_number, const MessageType& value, output) INL; |
| 469 | |
| 470 | #undef output |
| 471 | #undef input |
| 472 | #undef INL |
| 473 | |
| 474 | #undef field_number |
| 475 | |
| 476 | // Compute the byte size of a field. The XxSize() functions do NOT include |
| 477 | // the tag, so you must also call TagSize(). (This is because, for repeated |
| 478 | // fields, you should only call TagSize() once and multiply it by the element |
| 479 | // count, but you may have to call XxSize() for each individual element.) |
| 480 | static inline int Int32Size ( int32 value); |
| 481 | static inline int Int64Size ( int64 value); |
| 482 | static inline int UInt32Size (uint32 value); |
| 483 | static inline int UInt64Size (uint64 value); |
| 484 | static inline int SInt32Size ( int32 value); |
| 485 | static inline int SInt64Size ( int64 value); |
| 486 | static inline int EnumSize ( int value); |
| 487 | |
| 488 | // These types always have the same size. |
| 489 | static const int kFixed32Size = 4; |
| 490 | static const int kFixed64Size = 8; |
| 491 | static const int kSFixed32Size = 4; |
| 492 | static const int kSFixed64Size = 8; |
| 493 | static const int kFloatSize = 4; |
| 494 | static const int kDoubleSize = 8; |
| 495 | static const int kBoolSize = 1; |
| 496 | |
| 497 | static inline int StringSize(const string& value); |
| 498 | static inline int BytesSize (const string& value); |
| 499 | |
| 500 | static inline int GroupSize (const MessageLite& value); |
| 501 | static inline int MessageSize(const MessageLite& value); |
| 502 | |
| 503 | // Like above, but de-virtualize the call to ByteSize(). The |
| 504 | // pointer must point at an instance of MessageType, *not* a subclass (or |
| 505 | // the subclass must not override ByteSize()). |
| 506 | template<typename MessageType> |
| 507 | static inline int GroupSizeNoVirtual (const MessageType& value); |
| 508 | template<typename MessageType> |
| 509 | static inline int MessageSizeNoVirtual(const MessageType& value); |
| 510 | |
xiaofeng@google.com | b55a20f | 2012-09-22 02:40:50 +0000 | [diff] [blame] | 511 | // Given the length of data, calculate the byte size of the data on the |
| 512 | // wire if we encode the data as a length delimited field. |
| 513 | static inline int LengthDelimitedSize(int length); |
| 514 | |
kenton@google.com | 80b1d62 | 2009-07-29 01:13:20 +0000 | [diff] [blame] | 515 | private: |
kenton@google.com | fccb146 | 2009-12-18 02:11:36 +0000 | [diff] [blame] | 516 | // A helper method for the repeated primitive reader. This method has |
| 517 | // optimizations for primitive types that have fixed size on the wire, and |
| 518 | // can be read using potentially faster paths. |
| 519 | template <typename CType, enum FieldType DeclaredType> |
| 520 | static inline bool ReadRepeatedFixedSizePrimitive( |
| 521 | int tag_size, |
| 522 | uint32 tag, |
| 523 | google::protobuf::io::CodedInputStream* input, |
| 524 | RepeatedField<CType>* value) GOOGLE_ATTRIBUTE_ALWAYS_INLINE; |
| 525 | |
jieluo@google.com | 4de8f55 | 2014-07-18 00:47:59 +0000 | [diff] [blame] | 526 | // Like ReadRepeatedFixedSizePrimitive but for packed primitive fields. |
| 527 | template <typename CType, enum FieldType DeclaredType> |
| 528 | static inline bool ReadPackedFixedSizePrimitive( |
| 529 | google::protobuf::io::CodedInputStream* input, |
| 530 | RepeatedField<CType>* value) GOOGLE_ATTRIBUTE_ALWAYS_INLINE; |
| 531 | |
kenton@google.com | 80b1d62 | 2009-07-29 01:13:20 +0000 | [diff] [blame] | 532 | static const CppType kFieldTypeToCppTypeMap[]; |
| 533 | static const WireFormatLite::WireType kWireTypeForFieldType[]; |
| 534 | |
| 535 | GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(WireFormatLite); |
| 536 | }; |
| 537 | |
| 538 | // A class which deals with unknown values. The default implementation just |
| 539 | // discards them. WireFormat defines a subclass which writes to an |
| 540 | // UnknownFieldSet. This class is used by ExtensionSet::ParseField(), since |
| 541 | // ExtensionSet is part of the lite library but UnknownFieldSet is not. |
| 542 | class LIBPROTOBUF_EXPORT FieldSkipper { |
| 543 | public: |
| 544 | FieldSkipper() {} |
| 545 | virtual ~FieldSkipper() {} |
| 546 | |
| 547 | // Skip a field whose tag has already been consumed. |
| 548 | virtual bool SkipField(io::CodedInputStream* input, uint32 tag); |
| 549 | |
| 550 | // Skip an entire message or group, up to an end-group tag (which is consumed) |
| 551 | // or end-of-stream. |
| 552 | virtual bool SkipMessage(io::CodedInputStream* input); |
| 553 | |
| 554 | // Deal with an already-parsed unrecognized enum value. The default |
| 555 | // implementation does nothing, but the UnknownFieldSet-based implementation |
| 556 | // saves it as an unknown varint. |
| 557 | virtual void SkipUnknownEnum(int field_number, int value); |
| 558 | }; |
| 559 | |
jieluo@google.com | 4de8f55 | 2014-07-18 00:47:59 +0000 | [diff] [blame] | 560 | // Subclass of FieldSkipper which saves skipped fields to a CodedOutputStream. |
| 561 | |
| 562 | class LIBPROTOBUF_EXPORT CodedOutputStreamFieldSkipper : public FieldSkipper { |
| 563 | public: |
| 564 | explicit CodedOutputStreamFieldSkipper(io::CodedOutputStream* unknown_fields) |
| 565 | : unknown_fields_(unknown_fields) {} |
| 566 | virtual ~CodedOutputStreamFieldSkipper() {} |
| 567 | |
| 568 | // implements FieldSkipper ----------------------------------------- |
| 569 | virtual bool SkipField(io::CodedInputStream* input, uint32 tag); |
| 570 | virtual bool SkipMessage(io::CodedInputStream* input); |
| 571 | virtual void SkipUnknownEnum(int field_number, int value); |
| 572 | |
| 573 | protected: |
| 574 | io::CodedOutputStream* unknown_fields_; |
| 575 | }; |
| 576 | |
| 577 | |
kenton@google.com | 80b1d62 | 2009-07-29 01:13:20 +0000 | [diff] [blame] | 578 | // inline methods ==================================================== |
| 579 | |
| 580 | inline WireFormatLite::CppType |
| 581 | WireFormatLite::FieldTypeToCppType(FieldType type) { |
| 582 | return kFieldTypeToCppTypeMap[type]; |
| 583 | } |
| 584 | |
| 585 | inline uint32 WireFormatLite::MakeTag(int field_number, WireType type) { |
| 586 | return GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(field_number, type); |
| 587 | } |
| 588 | |
| 589 | inline WireFormatLite::WireType WireFormatLite::GetTagWireType(uint32 tag) { |
| 590 | return static_cast<WireType>(tag & kTagTypeMask); |
| 591 | } |
| 592 | |
| 593 | inline int WireFormatLite::GetTagFieldNumber(uint32 tag) { |
| 594 | return static_cast<int>(tag >> kTagTypeBits); |
| 595 | } |
| 596 | |
| 597 | inline int WireFormatLite::TagSize(int field_number, |
| 598 | WireFormatLite::FieldType type) { |
| 599 | int result = io::CodedOutputStream::VarintSize32( |
| 600 | field_number << kTagTypeBits); |
| 601 | if (type == TYPE_GROUP) { |
| 602 | // Groups have both a start and an end tag. |
| 603 | return result * 2; |
| 604 | } else { |
| 605 | return result; |
| 606 | } |
| 607 | } |
| 608 | |
| 609 | inline uint32 WireFormatLite::EncodeFloat(float value) { |
| 610 | union {float f; uint32 i;}; |
| 611 | f = value; |
| 612 | return i; |
| 613 | } |
| 614 | |
| 615 | inline float WireFormatLite::DecodeFloat(uint32 value) { |
| 616 | union {float f; uint32 i;}; |
| 617 | i = value; |
| 618 | return f; |
| 619 | } |
| 620 | |
| 621 | inline uint64 WireFormatLite::EncodeDouble(double value) { |
| 622 | union {double f; uint64 i;}; |
| 623 | f = value; |
| 624 | return i; |
| 625 | } |
| 626 | |
| 627 | inline double WireFormatLite::DecodeDouble(uint64 value) { |
| 628 | union {double f; uint64 i;}; |
| 629 | i = value; |
| 630 | return f; |
| 631 | } |
| 632 | |
| 633 | // ZigZag Transform: Encodes signed integers so that they can be |
| 634 | // effectively used with varint encoding. |
| 635 | // |
| 636 | // varint operates on unsigned integers, encoding smaller numbers into |
| 637 | // fewer bytes. If you try to use it on a signed integer, it will treat |
| 638 | // this number as a very large unsigned integer, which means that even |
| 639 | // small signed numbers like -1 will take the maximum number of bytes |
| 640 | // (10) to encode. ZigZagEncode() maps signed integers to unsigned |
| 641 | // in such a way that those with a small absolute value will have smaller |
| 642 | // encoded values, making them appropriate for encoding using varint. |
| 643 | // |
| 644 | // int32 -> uint32 |
| 645 | // ------------------------- |
| 646 | // 0 -> 0 |
| 647 | // -1 -> 1 |
| 648 | // 1 -> 2 |
| 649 | // -2 -> 3 |
| 650 | // ... -> ... |
| 651 | // 2147483647 -> 4294967294 |
| 652 | // -2147483648 -> 4294967295 |
| 653 | // |
| 654 | // >> encode >> |
| 655 | // << decode << |
| 656 | |
| 657 | inline uint32 WireFormatLite::ZigZagEncode32(int32 n) { |
| 658 | // Note: the right-shift must be arithmetic |
Jisi Liu | 885b612 | 2015-02-28 14:51:22 -0800 | [diff] [blame^] | 659 | return (static_cast<uint32>(n) << 1) ^ (n >> 31); |
kenton@google.com | 80b1d62 | 2009-07-29 01:13:20 +0000 | [diff] [blame] | 660 | } |
| 661 | |
| 662 | inline int32 WireFormatLite::ZigZagDecode32(uint32 n) { |
| 663 | return (n >> 1) ^ -static_cast<int32>(n & 1); |
| 664 | } |
| 665 | |
| 666 | inline uint64 WireFormatLite::ZigZagEncode64(int64 n) { |
| 667 | // Note: the right-shift must be arithmetic |
Jisi Liu | 885b612 | 2015-02-28 14:51:22 -0800 | [diff] [blame^] | 668 | return (static_cast<uint64>(n) << 1) ^ (n >> 63); |
kenton@google.com | 80b1d62 | 2009-07-29 01:13:20 +0000 | [diff] [blame] | 669 | } |
| 670 | |
| 671 | inline int64 WireFormatLite::ZigZagDecode64(uint64 n) { |
| 672 | return (n >> 1) ^ -static_cast<int64>(n & 1); |
| 673 | } |
| 674 | |
Feng Xiao | 6ef984a | 2014-11-10 17:34:54 -0800 | [diff] [blame] | 675 | // String is for UTF-8 text only, but, even so, ReadString() can simply |
| 676 | // call ReadBytes(). |
| 677 | |
| 678 | inline bool WireFormatLite::ReadString(io::CodedInputStream* input, |
| 679 | string* value) { |
| 680 | return ReadBytes(input, value); |
| 681 | } |
| 682 | |
| 683 | inline bool WireFormatLite::ReadString(io::CodedInputStream* input, |
| 684 | string** p) { |
| 685 | return ReadBytes(input, p); |
| 686 | } |
| 687 | |
kenton@google.com | 80b1d62 | 2009-07-29 01:13:20 +0000 | [diff] [blame] | 688 | } // namespace internal |
| 689 | } // namespace protobuf |
| 690 | |
| 691 | } // namespace google |
| 692 | #endif // GOOGLE_PROTOBUF_WIRE_FORMAT_LITE_H__ |