| // Protocol Buffers - Google's data interchange format | |
| // Copyright 2008 Google Inc. All rights reserved. | |
| // https://developers.google.com/protocol-buffers/ | |
| // | |
| // Redistribution and use in source and binary forms, with or without | |
| // modification, are permitted provided that the following conditions are | |
| // met: | |
| // | |
| // * Redistributions of source code must retain the above copyright | |
| // notice, this list of conditions and the following disclaimer. | |
| // * Redistributions in binary form must reproduce the above | |
| // copyright notice, this list of conditions and the following disclaimer | |
| // in the documentation and/or other materials provided with the | |
| // distribution. | |
| // * Neither the name of Google Inc. nor the names of its | |
| // contributors may be used to endorse or promote products derived from | |
| // this software without specific prior written permission. | |
| // | |
| // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | |
| // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | |
| // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | |
| // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT | |
| // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | |
| // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT | |
| // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | |
| // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | |
| // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | |
| // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | |
| // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
| // Author: kenton@google.com (Kenton Varda) | |
| // atenasio@google.com (Chris Atenasio) (ZigZag transform) | |
| // Based on original Protocol Buffers design by | |
| // Sanjay Ghemawat, Jeff Dean, and others. | |
| // | |
| // This header is logically internal, but is made public because it is used | |
| // from protocol-compiler-generated code, which may reside in other components. | |
| namespace google { | |
| namespace protobuf { | |
| namespace io { | |
| class CodedInputStream; // coded_stream.h | |
| class CodedOutputStream; // coded_stream.h | |
| } | |
| class UnknownFieldSet; // unknown_field_set.h | |
| } | |
| namespace protobuf { | |
| namespace internal { | |
| // This class is for internal use by the protocol buffer library and by | |
| // protocol-complier-generated message classes. It must not be called | |
| // directly by clients. | |
| // | |
| // This class contains code for implementing the binary protocol buffer | |
| // wire format via reflection. The WireFormatLite class implements the | |
| // non-reflection based routines. | |
| // | |
| // This class is really a namespace that contains only static methods | |
| class LIBPROTOBUF_EXPORT WireFormat { | |
| public: | |
| // Given a field return its WireType | |
| static inline WireFormatLite::WireType WireTypeForField( | |
| const FieldDescriptor* field); | |
| // Given a FieldDescriptor::Type return its WireType | |
| static inline WireFormatLite::WireType WireTypeForFieldType( | |
| FieldDescriptor::Type type); | |
| // Compute the byte size of a tag. For groups, this includes both the start | |
| // and end tags. | |
| static inline size_t TagSize(int field_number, FieldDescriptor::Type type); | |
| // These procedures can be used to implement the methods of Message which | |
| // handle parsing and serialization of the protocol buffer wire format | |
| // using only the Reflection interface. When you ask the protocol | |
| // compiler to optimize for code size rather than speed, it will implement | |
| // those methods in terms of these procedures. Of course, these are much | |
| // slower than the specialized implementations which the protocol compiler | |
| // generates when told to optimize for speed. | |
| // Read a message in protocol buffer wire format. | |
| // | |
| // This procedure reads either to the end of the input stream or through | |
| // a WIRETYPE_END_GROUP tag ending the message, whichever comes first. | |
| // It returns false if the input is invalid. | |
| // | |
| // Required fields are NOT checked by this method. You must call | |
| // IsInitialized() on the resulting message yourself. | |
| static bool ParseAndMergePartial(io::CodedInputStream* input, | |
| Message* message); | |
| // Serialize a message in protocol buffer wire format. | |
| // | |
| // Any embedded messages within the message must have their correct sizes | |
| // cached. However, the top-level message need not; its size is passed as | |
| // a parameter to this procedure. | |
| // | |
| // These return false iff the underlying stream returns a write error. | |
| static void SerializeWithCachedSizes( | |
| const Message& message, | |
| int size, io::CodedOutputStream* output); | |
| // Implements Message::ByteSize() via reflection. WARNING: The result | |
| // of this method is *not* cached anywhere. However, all embedded messages | |
| // will have their ByteSize() methods called, so their sizes will be cached. | |
| // Therefore, calling this method is sufficient to allow you to call | |
| // WireFormat::SerializeWithCachedSizes() on the same object. | |
| static size_t ByteSize(const Message& message); | |
| // ----------------------------------------------------------------- | |
| // Helpers for dealing with unknown fields | |
| // Skips a field value of the given WireType. The input should start | |
| // positioned immediately after the tag. If unknown_fields is non-NULL, | |
| // the contents of the field will be added to it. | |
| static bool SkipField(io::CodedInputStream* input, uint32 tag, | |
| UnknownFieldSet* unknown_fields); | |
| // Reads and ignores a message from the input. If unknown_fields is non-NULL, | |
| // the contents will be added to it. | |
| static bool SkipMessage(io::CodedInputStream* input, | |
| UnknownFieldSet* unknown_fields); | |
| // Read a packed enum field. If the is_valid function is not NULL, values for | |
| // which is_valid(value) returns false are appended to unknown_fields_stream. | |
| static bool ReadPackedEnumPreserveUnknowns(io::CodedInputStream* input, | |
| uint32 field_number, | |
| bool (*is_valid)(int), | |
| UnknownFieldSet* unknown_fields, | |
| RepeatedField<int>* values); | |
| // Write the contents of an UnknownFieldSet to the output. | |
| static void SerializeUnknownFields(const UnknownFieldSet& unknown_fields, | |
| io::CodedOutputStream* output); | |
| // Same as above, except writing directly to the provided buffer. | |
| // Requires that the buffer have sufficient capacity for | |
| // ComputeUnknownFieldsSize(unknown_fields). | |
| // | |
| // Returns a pointer past the last written byte. | |
| static uint8* SerializeUnknownFieldsToArray( | |
| const UnknownFieldSet& unknown_fields, | |
| uint8* target); | |
| // Same thing except for messages that have the message_set_wire_format | |
| // option. | |
| static void SerializeUnknownMessageSetItems( | |
| const UnknownFieldSet& unknown_fields, | |
| io::CodedOutputStream* output); | |
| // Same as above, except writing directly to the provided buffer. | |
| // Requires that the buffer have sufficient capacity for | |
| // ComputeUnknownMessageSetItemsSize(unknown_fields). | |
| // | |
| // Returns a pointer past the last written byte. | |
| static uint8* SerializeUnknownMessageSetItemsToArray( | |
| const UnknownFieldSet& unknown_fields, | |
| uint8* target); | |
| // Compute the size of the UnknownFieldSet on the wire. | |
| static size_t ComputeUnknownFieldsSize(const UnknownFieldSet& unknown_fields); | |
| // Same thing except for messages that have the message_set_wire_format | |
| // option. | |
| static size_t ComputeUnknownMessageSetItemsSize( | |
| const UnknownFieldSet& unknown_fields); | |
| // Helper functions for encoding and decoding tags. (Inlined below and in | |
| // _inl.h) | |
| // | |
| // This is different from MakeTag(field->number(), field->type()) in the case | |
| // of packed repeated fields. | |
| static uint32 MakeTag(const FieldDescriptor* field); | |
| // Parse a single field. The input should start out positioned immediately | |
| // after the tag. | |
| static bool ParseAndMergeField( | |
| uint32 tag, | |
| const FieldDescriptor* field, // May be NULL for unknown | |
| Message* message, | |
| io::CodedInputStream* input); | |
| // Serialize a single field. | |
| static void SerializeFieldWithCachedSizes( | |
| const FieldDescriptor* field, // Cannot be NULL | |
| const Message& message, | |
| io::CodedOutputStream* output); | |
| // Compute size of a single field. If the field is a message type, this | |
| // will call ByteSize() for the embedded message, insuring that it caches | |
| // its size. | |
| static size_t FieldByteSize( | |
| const FieldDescriptor* field, // Cannot be NULL | |
| const Message& message); | |
| // Parse/serialize a MessageSet::Item group. Used with messages that use | |
| // opion message_set_wire_format = true. | |
| static bool ParseAndMergeMessageSetItem( | |
| io::CodedInputStream* input, | |
| Message* message); | |
| static void SerializeMessageSetItemWithCachedSizes( | |
| const FieldDescriptor* field, | |
| const Message& message, | |
| io::CodedOutputStream* output); | |
| static size_t MessageSetItemByteSize( | |
| const FieldDescriptor* field, | |
| const Message& message); | |
| // Computes the byte size of a field, excluding tags. For packed fields, it | |
| // only includes the size of the raw data, and not the size of the total | |
| // length, but for other length-delimited types, the size of the length is | |
| // included. | |
| static size_t FieldDataOnlyByteSize( | |
| const FieldDescriptor* field, // Cannot be NULL | |
| const Message& message); | |
| enum Operation { | |
| PARSE = 0, | |
| SERIALIZE = 1, | |
| }; | |
| // Verifies that a string field is valid UTF8, logging an error if not. | |
| // This function will not be called by newly generated protobuf code | |
| // but remains present to support existing code. | |
| static void VerifyUTF8String(const char* data, int size, Operation op); | |
| // The NamedField variant takes a field name in order to produce an | |
| // informative error message if verification fails. | |
| static void VerifyUTF8StringNamedField(const char* data, | |
| int size, | |
| Operation op, | |
| const char* field_name); | |
| private: | |
| // Skip a MessageSet field. | |
| static bool SkipMessageSetField(io::CodedInputStream* input, | |
| uint32 field_number, | |
| UnknownFieldSet* unknown_fields); | |
| // Parse a MessageSet field. | |
| static bool ParseAndMergeMessageSetField(uint32 field_number, | |
| const FieldDescriptor* field, | |
| Message* message, | |
| io::CodedInputStream* input); | |
| GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(WireFormat); | |
| }; | |
| // Subclass of FieldSkipper which saves skipped fields to an UnknownFieldSet. | |
| class LIBPROTOBUF_EXPORT UnknownFieldSetFieldSkipper : public FieldSkipper { | |
| public: | |
| UnknownFieldSetFieldSkipper(UnknownFieldSet* unknown_fields) | |
| : unknown_fields_(unknown_fields) {} | |
| virtual ~UnknownFieldSetFieldSkipper() {} | |
| // implements FieldSkipper ----------------------------------------- | |
| virtual bool SkipField(io::CodedInputStream* input, uint32 tag); | |
| virtual bool SkipMessage(io::CodedInputStream* input); | |
| virtual void SkipUnknownEnum(int field_number, int value); | |
| protected: | |
| UnknownFieldSet* unknown_fields_; | |
| }; | |
| // inline methods ==================================================== | |
| inline WireFormatLite::WireType WireFormat::WireTypeForField( | |
| const FieldDescriptor* field) { | |
| if (field->is_packed()) { | |
| return WireFormatLite::WIRETYPE_LENGTH_DELIMITED; | |
| } else { | |
| return WireTypeForFieldType(field->type()); | |
| } | |
| } | |
| inline WireFormatLite::WireType WireFormat::WireTypeForFieldType( | |
| FieldDescriptor::Type type) { | |
| // Some compilers don't like enum -> enum casts, so we implicit_cast to | |
| // int first. | |
| return WireFormatLite::WireTypeForFieldType( | |
| static_cast<WireFormatLite::FieldType>( | |
| implicit_cast<int>(type))); | |
| } | |
| inline uint32 WireFormat::MakeTag(const FieldDescriptor* field) { | |
| return WireFormatLite::MakeTag(field->number(), WireTypeForField(field)); | |
| } | |
| inline size_t WireFormat::TagSize(int field_number, | |
| FieldDescriptor::Type type) { | |
| // Some compilers don't like enum -> enum casts, so we implicit_cast to | |
| // int first. | |
| return WireFormatLite::TagSize(field_number, | |
| static_cast<WireFormatLite::FieldType>( | |
| implicit_cast<int>(type))); | |
| } | |
| inline void WireFormat::VerifyUTF8String(const char* data, int size, | |
| WireFormat::Operation op) { | |
| WireFormatLite::VerifyUtf8String( | |
| data, size, static_cast<WireFormatLite::Operation>(op), NULL); | |
| // Avoid the compiler warning about unused variables. | |
| (void)data; (void)size; (void)op; | |
| } | |
| inline void WireFormat::VerifyUTF8StringNamedField( | |
| const char* data, int size, WireFormat::Operation op, | |
| const char* field_name) { | |
| WireFormatLite::VerifyUtf8String( | |
| data, size, static_cast<WireFormatLite::Operation>(op), field_name); | |
| // Avoid the compiler warning about unused variables. | |
| (void)data; (void)size; (void)op; (void)field_name; | |
| } | |
| } // namespace internal | |
| } // namespace protobuf | |
| } // namespace google | |