| // Protocol Buffers - Google's data interchange format |
| // Copyright 2008 Google Inc. All rights reserved. |
| // http://code.google.com/p/protobuf/ |
| // |
| // 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) |
| // Based on original Protocol Buffers design by |
| // Sanjay Ghemawat, Jeff Dean, and others. |
| // |
| // Contains classes used to keep track of unrecognized fields seen while |
| // parsing a protocol message. |
| |
| #ifndef GOOGLE_PROTOBUF_UNKNOWN_FIELD_SET_H__ |
| #define GOOGLE_PROTOBUF_UNKNOWN_FIELD_SET_H__ |
| |
| #include <assert.h> |
| #include <string> |
| #include <vector> |
| #include <google/protobuf/stubs/common.h> |
| // TODO(jasonh): some people seem to rely on protobufs to include this for them! |
| |
| namespace google { |
| namespace protobuf { |
| namespace io { |
| class CodedInputStream; // coded_stream.h |
| class CodedOutputStream; // coded_stream.h |
| class ZeroCopyInputStream; // zero_copy_stream.h |
| } |
| namespace internal { |
| class WireFormat; // wire_format.h |
| class UnknownFieldSetFieldSkipperUsingCord; |
| // extension_set_heavy.cc |
| } |
| |
| class Message; // message.h |
| class UnknownField; // below |
| |
| // An UnknownFieldSet contains fields that were encountered while parsing a |
| // message but were not defined by its type. Keeping track of these can be |
| // useful, especially in that they may be written if the message is serialized |
| // again without being cleared in between. This means that software which |
| // simply receives messages and forwards them to other servers does not need |
| // to be updated every time a new field is added to the message definition. |
| // |
| // To get the UnknownFieldSet attached to any message, call |
| // Reflection::GetUnknownFields(). |
| // |
| // This class is necessarily tied to the protocol buffer wire format, unlike |
| // the Reflection interface which is independent of any serialization scheme. |
| class LIBPROTOBUF_EXPORT UnknownFieldSet { |
| public: |
| UnknownFieldSet(); |
| ~UnknownFieldSet(); |
| |
| // Remove all fields. |
| inline void Clear(); |
| |
| // Remove all fields and deallocate internal data objects |
| void ClearAndFreeMemory(); |
| |
| // Is this set empty? |
| inline bool empty() const; |
| |
| // Merge the contents of some other UnknownFieldSet with this one. |
| void MergeFrom(const UnknownFieldSet& other); |
| |
| // Swaps the contents of some other UnknownFieldSet with this one. |
| inline void Swap(UnknownFieldSet* x); |
| |
| // Computes (an estimate of) the total number of bytes currently used for |
| // storing the unknown fields in memory. Does NOT include |
| // sizeof(*this) in the calculation. |
| int SpaceUsedExcludingSelf() const; |
| |
| // Version of SpaceUsed() including sizeof(*this). |
| int SpaceUsed() const; |
| |
| // Returns the number of fields present in the UnknownFieldSet. |
| inline int field_count() const; |
| // Get a field in the set, where 0 <= index < field_count(). The fields |
| // appear in the order in which they were added. |
| inline const UnknownField& field(int index) const; |
| // Get a mutable pointer to a field in the set, where |
| // 0 <= index < field_count(). The fields appear in the order in which |
| // they were added. |
| inline UnknownField* mutable_field(int index); |
| |
| // Adding fields --------------------------------------------------- |
| |
| void AddVarint(int number, uint64 value); |
| void AddFixed32(int number, uint32 value); |
| void AddFixed64(int number, uint64 value); |
| void AddLengthDelimited(int number, const string& value); |
| string* AddLengthDelimited(int number); |
| UnknownFieldSet* AddGroup(int number); |
| |
| // Adds an unknown field from another set. |
| void AddField(const UnknownField& field); |
| |
| // Delete fields with indices in the range [start .. start+num-1]. |
| // Caution: implementation moves all fields with indices [start+num .. ]. |
| void DeleteSubrange(int start, int num); |
| |
| // Delete all fields with a specific field number. The order of left fields |
| // is preserved. |
| // Caution: implementation moves all fields after the first deleted field. |
| void DeleteByNumber(int number); |
| |
| // Parsing helpers ------------------------------------------------- |
| // These work exactly like the similarly-named methods of Message. |
| |
| bool MergeFromCodedStream(io::CodedInputStream* input); |
| bool ParseFromCodedStream(io::CodedInputStream* input); |
| bool ParseFromZeroCopyStream(io::ZeroCopyInputStream* input); |
| bool ParseFromArray(const void* data, int size); |
| inline bool ParseFromString(const string& data) { |
| return ParseFromArray(data.data(), data.size()); |
| } |
| |
| private: |
| |
| void ClearFallback(); |
| |
| vector<UnknownField>* fields_; |
| |
| GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(UnknownFieldSet); |
| }; |
| |
| // Represents one field in an UnknownFieldSet. |
| class LIBPROTOBUF_EXPORT UnknownField { |
| public: |
| enum Type { |
| TYPE_VARINT, |
| TYPE_FIXED32, |
| TYPE_FIXED64, |
| TYPE_LENGTH_DELIMITED, |
| TYPE_GROUP |
| }; |
| |
| // The field's tag number, as seen on the wire. |
| inline int number() const; |
| |
| // The field type. |
| inline Type type() const; |
| |
| // Accessors ------------------------------------------------------- |
| // Each method works only for UnknownFields of the corresponding type. |
| |
| inline uint64 varint() const; |
| inline uint32 fixed32() const; |
| inline uint64 fixed64() const; |
| inline const string& length_delimited() const; |
| inline const UnknownFieldSet& group() const; |
| |
| inline void set_varint(uint64 value); |
| inline void set_fixed32(uint32 value); |
| inline void set_fixed64(uint64 value); |
| inline void set_length_delimited(const string& value); |
| inline string* mutable_length_delimited(); |
| inline UnknownFieldSet* mutable_group(); |
| |
| // Serialization API. |
| // These methods can take advantage of the underlying implementation and may |
| // archieve a better performance than using getters to retrieve the data and |
| // do the serialization yourself. |
| void SerializeLengthDelimitedNoTag(io::CodedOutputStream* output) const; |
| uint8* SerializeLengthDelimitedNoTagToArray(uint8* target) const; |
| |
| inline int GetLengthDelimitedSize() const; |
| |
| private: |
| friend class UnknownFieldSet; |
| |
| // If this UnknownField contains a pointer, delete it. |
| void Delete(); |
| |
| // Make a deep copy of any pointers in this UnknownField. |
| void DeepCopy(); |
| |
| |
| unsigned int number_ : 29; |
| unsigned int type_ : 3; |
| union { |
| uint64 varint_; |
| uint32 fixed32_; |
| uint64 fixed64_; |
| mutable union { |
| string* string_value_; |
| } length_delimited_; |
| UnknownFieldSet* group_; |
| }; |
| }; |
| |
| // =================================================================== |
| // inline implementations |
| |
| inline void UnknownFieldSet::Clear() { |
| if (fields_ != NULL) { |
| ClearFallback(); |
| } |
| } |
| |
| inline bool UnknownFieldSet::empty() const { |
| return fields_ == NULL || fields_->empty(); |
| } |
| |
| inline void UnknownFieldSet::Swap(UnknownFieldSet* x) { |
| std::swap(fields_, x->fields_); |
| } |
| |
| inline int UnknownFieldSet::field_count() const { |
| return (fields_ == NULL) ? 0 : fields_->size(); |
| } |
| inline const UnknownField& UnknownFieldSet::field(int index) const { |
| return (*fields_)[index]; |
| } |
| inline UnknownField* UnknownFieldSet::mutable_field(int index) { |
| return &(*fields_)[index]; |
| } |
| |
| inline void UnknownFieldSet::AddLengthDelimited( |
| int number, const string& value) { |
| AddLengthDelimited(number)->assign(value); |
| } |
| |
| |
| inline int UnknownField::number() const { return number_; } |
| inline UnknownField::Type UnknownField::type() const { |
| return static_cast<Type>(type_); |
| } |
| |
| inline uint64 UnknownField::varint () const { |
| assert(type_ == TYPE_VARINT); |
| return varint_; |
| } |
| inline uint32 UnknownField::fixed32() const { |
| assert(type_ == TYPE_FIXED32); |
| return fixed32_; |
| } |
| inline uint64 UnknownField::fixed64() const { |
| assert(type_ == TYPE_FIXED64); |
| return fixed64_; |
| } |
| inline const string& UnknownField::length_delimited() const { |
| assert(type_ == TYPE_LENGTH_DELIMITED); |
| return *length_delimited_.string_value_; |
| } |
| inline const UnknownFieldSet& UnknownField::group() const { |
| assert(type_ == TYPE_GROUP); |
| return *group_; |
| } |
| |
| inline void UnknownField::set_varint(uint64 value) { |
| assert(type_ == TYPE_VARINT); |
| varint_ = value; |
| } |
| inline void UnknownField::set_fixed32(uint32 value) { |
| assert(type_ == TYPE_FIXED32); |
| fixed32_ = value; |
| } |
| inline void UnknownField::set_fixed64(uint64 value) { |
| assert(type_ == TYPE_FIXED64); |
| fixed64_ = value; |
| } |
| inline void UnknownField::set_length_delimited(const string& value) { |
| assert(type_ == TYPE_LENGTH_DELIMITED); |
| length_delimited_.string_value_->assign(value); |
| } |
| inline string* UnknownField::mutable_length_delimited() { |
| assert(type_ == TYPE_LENGTH_DELIMITED); |
| return length_delimited_.string_value_; |
| } |
| inline UnknownFieldSet* UnknownField::mutable_group() { |
| assert(type_ == TYPE_GROUP); |
| return group_; |
| } |
| |
| inline int UnknownField::GetLengthDelimitedSize() const { |
| GOOGLE_DCHECK_EQ(TYPE_LENGTH_DELIMITED, type_); |
| return length_delimited_.string_value_->size(); |
| } |
| |
| } // namespace protobuf |
| |
| } // namespace google |
| #endif // GOOGLE_PROTOBUF_UNKNOWN_FIELD_SET_H__ |