diff options
Diffstat (limited to 'src/google/protobuf/unknown_field_set.h')
-rw-r--r-- | src/google/protobuf/unknown_field_set.h | 415 |
1 files changed, 94 insertions, 321 deletions
diff --git a/src/google/protobuf/unknown_field_set.h b/src/google/protobuf/unknown_field_set.h index f17012df..d6ca70fc 100644 --- a/src/google/protobuf/unknown_field_set.h +++ b/src/google/protobuf/unknown_field_set.h @@ -39,7 +39,6 @@ #define GOOGLE_PROTOBUF_UNKNOWN_FIELD_SET_H__ #include <string> -#include <map> #include <vector> #include <google/protobuf/repeated_field.h> @@ -70,13 +69,6 @@ class LIBPROTOBUF_EXPORT UnknownFieldSet { void Clear(); // Is this set empty? - // - // Note that this is equivalent to field_count() == 0 but is NOT necessarily - // equivalent to begin() == end(). The iterator class skips fields which are - // themselves empty, so if field_count() is non-zero but field(i)->empty() is - // true for all i, then begin() will be equal to end() but empty() will return - // false. This inconsistency almost never occurs in practice because typical - // code does not add empty fields to an UnknownFieldSet. inline bool empty() const; // Merge the contents of some other UnknownFieldSet with this one. @@ -85,13 +77,6 @@ class LIBPROTOBUF_EXPORT UnknownFieldSet { // Swaps the contents of some other UnknownFieldSet with this one. inline void Swap(UnknownFieldSet* x); - // Find a field by field number. Returns NULL if not found. - const UnknownField* FindFieldByNumber(int number) const; - - // Add a field by field number. If the field number already exists, returns - // the existing UnknownField. - UnknownField* AddField(int number); - // 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. @@ -100,111 +85,28 @@ class LIBPROTOBUF_EXPORT UnknownFieldSet { // Version of SpaceUsed() including sizeof(*this). int SpaceUsed() const; - // STL-style iteration --------------------------------------------- - // These iterate over the non-empty UnknownFields in order by field - // number. All iterators are invalidated whenever the UnknownFieldSet - // is modified. - - class const_iterator; - - class LIBPROTOBUF_EXPORT iterator { - public: - iterator() {} - - bool operator==(const iterator& other) { - return inner_iterator_ == other.inner_iterator_; - } - bool operator!=(const iterator& other) { - return inner_iterator_ != other.inner_iterator_; - } - - UnknownField& operator*() { return *inner_iterator_->second; } - UnknownField* operator->() { return inner_iterator_->second; } - iterator& operator++() { - ++inner_iterator_; - AdvanceToNonEmpty(); - return *this; - } - iterator operator++(int) { - iterator copy(*this); - ++*this; - return copy; - } - - private: - friend class UnknownFieldSet; - friend class LIBPROTOBUF_EXPORT UnknownFieldSet::const_iterator; - iterator(map<int, UnknownField*>::iterator inner_iterator, - map<int, UnknownField*>* inner_map) - : inner_iterator_(inner_iterator), inner_map_(inner_map) {} - - void AdvanceToNonEmpty(); - - map<int, UnknownField*>::iterator inner_iterator_; - map<int, UnknownField*>* inner_map_; - }; - - class LIBPROTOBUF_EXPORT const_iterator { - public: - const_iterator() {} - const_iterator(const iterator& other) - : inner_iterator_(other.inner_iterator_), inner_map_(other.inner_map_) {} - - bool operator==(const const_iterator& other) { - return inner_iterator_ == other.inner_iterator_; - } - bool operator!=(const const_iterator& other) { - return inner_iterator_ != other.inner_iterator_; - } - - UnknownField& operator*() { return *inner_iterator_->second; } - UnknownField* operator->() { return inner_iterator_->second; } - const_iterator& operator++() { - ++inner_iterator_; - AdvanceToNonEmpty(); - return *this; - } - const_iterator operator++(int) { - const_iterator copy(*this); - ++*this; - return copy; - } - - private: - friend class UnknownFieldSet; - const_iterator(map<int, UnknownField*>::const_iterator inner_iterator, - const map<int, UnknownField*>* inner_map) - : inner_iterator_(inner_iterator), inner_map_(inner_map) {} - - void AdvanceToNonEmpty(); - - map<int, UnknownField*>::const_iterator inner_iterator_; - const map<int, UnknownField*>* inner_map_; - }; - - iterator begin(); - iterator end() { - return internal_ == NULL ? kEmptyIterator : - iterator(internal_->fields_.end(), &internal_->fields_); - } - const_iterator begin() const; - const_iterator end() const { - return internal_ == NULL ? kEmptyConstIterator : - const_iterator(internal_->fields_.end(), &internal_->fields_); - } - - // Old-style iteration --------------------------------------------- - // New code should use begin() and end() rather than these methods. - // 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 arbitrary order. + // 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 arbitrary order. + // 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); + // Parsing helpers ------------------------------------------------- // These work exactly like the similarly-named methods of Message. @@ -217,268 +119,139 @@ class LIBPROTOBUF_EXPORT UnknownFieldSet { } private: - // "Active" fields are ones which have been added since the last time Clear() - // was called. Inactive fields are objects we are keeping around incase - // they become active again. - - struct Internal { - // Contains all UnknownFields that have been allocated for this - // UnknownFieldSet, including ones not currently active. Keyed by - // field number. We intentionally try to reuse UnknownField objects for - // the same field number they were used for originally because this makes - // it more likely that the previously-allocated memory will have the right - // layout. - typedef map<int, UnknownField*> FieldMap; - FieldMap fields_; - - // Contains the fields from fields_ that are currently active. - typedef vector<UnknownField*> FieldVector; - FieldVector active_fields_; - }; - - // We want an UnknownFieldSet to use no more space than a single pointer - // until the first field is added. - Internal* internal_; - - // Don't keep more inactive fields than this. - static const int kMaxInactiveFields = 100; - - // Used by begin() and end() when internal_ is NULL. - static Internal::FieldMap kEmptyMap; - static const iterator kEmptyIterator; - static const const_iterator kEmptyConstIterator; + vector<UnknownField>* fields_; GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(UnknownFieldSet); }; // Represents one field in an UnknownFieldSet. -// -// UnknownField's accessors are similar to those that would be produced by the -// protocol compiler for the fields: -// repeated uint64 varint; -// repeated fixed32 fixed32; -// repeated fixed64 fixed64; -// repeated bytes length_delimited; -// repeated UnknownFieldSet group; -// (OK, so the last one isn't actually a valid field type but you get the -// idea.) class LIBPROTOBUF_EXPORT UnknownField { public: - ~UnknownField(); + enum Type { + TYPE_VARINT, + TYPE_FIXED32, + TYPE_FIXED64, + TYPE_LENGTH_DELIMITED, + TYPE_GROUP + }; - // Clears all fields. - void Clear(); + // The field's tag number, as seen on the wire. + inline int number() const; - // Is this field empty? (I.e. all of the *_size() methods return zero.) - inline bool empty() const; + // The field type. + inline Type type() const; - // Merge the contents of some other UnknownField with this one. For each - // wire type, the values are simply concatenated. - void MergeFrom(const UnknownField& other); + // Accessors ------------------------------------------------------- + // Each method works only for UnknownFields of the corresponding type. - // The field's tag number, as seen on the wire. - inline int number() const; + inline uint64 varint() const; + inline uint32 fixed32() const; + inline uint64 fixed64() const; + inline const string& length_delimited() const; + inline const UnknownFieldSet& group() const; - // The index of this UnknownField within the UnknownFieldSet (e.g. - // set.field(field.index()) == field). - inline int index() const; - - inline int varint_size () const; - inline int fixed32_size () const; - inline int fixed64_size () const; - inline int length_delimited_size() const; - inline int group_size () const; - - inline uint64 varint (int index) const; - inline uint32 fixed32(int index) const; - inline uint64 fixed64(int index) const; - inline const string& length_delimited(int index) const; - inline const UnknownFieldSet& group(int index) const; - - inline void set_varint (int index, uint64 value); - inline void set_fixed32(int index, uint32 value); - inline void set_fixed64(int index, uint64 value); - inline void set_length_delimited(int index, const string& value); - inline string* mutable_length_delimited(int index); - inline UnknownFieldSet* mutable_group(int index); - - inline void add_varint (uint64 value); - inline void add_fixed32(uint32 value); - inline void add_fixed64(uint64 value); - inline void add_length_delimited(const string& value); - inline string* add_length_delimited(); - inline UnknownFieldSet* add_group(); - - inline void clear_varint (); - inline void clear_fixed32(); - inline void clear_fixed64(); - inline void clear_length_delimited(); - inline void clear_group(); - - inline const RepeatedField <uint64 >& varint () const; - inline const RepeatedField <uint32 >& fixed32 () const; - inline const RepeatedField <uint64 >& fixed64 () const; - inline const RepeatedPtrField<string >& length_delimited() const; - inline const RepeatedPtrField<UnknownFieldSet>& group () const; - - inline RepeatedField <uint64 >* mutable_varint (); - inline RepeatedField <uint32 >* mutable_fixed32 (); - inline RepeatedField <uint64 >* mutable_fixed64 (); - inline RepeatedPtrField<string >* mutable_length_delimited(); - inline RepeatedPtrField<UnknownFieldSet>* mutable_group (); - - // Returns (an estimate of) the total number of bytes used to represent the - // unknown field. - int SpaceUsed() 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(); private: friend class UnknownFieldSet; - UnknownField(int number); - int number_; - int index_; + // If this UnknownField contains a pointer, delete it. + void Delete(); - RepeatedField <uint64 > varint_; - RepeatedField <uint32 > fixed32_; - RepeatedField <uint64 > fixed64_; - RepeatedPtrField<string > length_delimited_; - RepeatedPtrField<UnknownFieldSet> group_; + // Make a deep copy of any pointers in this UnknownField. + void DeepCopy(); - GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(UnknownField); + unsigned int number_ : 29; + unsigned int type_ : 3; + union { + uint64 varint_; + uint32 fixed32_; + uint64 fixed64_; + string* length_delimited_; + UnknownFieldSet* group_; + }; }; // =================================================================== // inline implementations inline bool UnknownFieldSet::empty() const { - return internal_ == NULL || internal_->active_fields_.empty(); + return fields_ == NULL || fields_->empty(); } inline void UnknownFieldSet::Swap(UnknownFieldSet* x) { - std::swap(internal_, x->internal_); + std::swap(fields_, x->fields_); } inline int UnknownFieldSet::field_count() const { - return (internal_ == NULL) ? 0 : internal_->active_fields_.size(); + return (fields_ == NULL) ? 0 : fields_->size(); } inline const UnknownField& UnknownFieldSet::field(int index) const { - return *(internal_->active_fields_[index]); + return (*fields_)[index]; } inline UnknownField* UnknownFieldSet::mutable_field(int index) { - return internal_->active_fields_[index]; + return &(*fields_)[index]; } -inline bool UnknownField::empty() const { - return varint_.size() == 0 && - fixed32_.size() == 0 && - fixed64_.size() == 0 && - length_delimited_.size() == 0 && - group_.size() == 0; +inline void UnknownFieldSet::AddLengthDelimited( + int number, const string& value) { + AddLengthDelimited(number)->assign(value); } inline int UnknownField::number() const { return number_; } -inline int UnknownField::index () const { return index_; } - -inline int UnknownField::varint_size () const {return varint_.size();} -inline int UnknownField::fixed32_size () const {return fixed32_.size();} -inline int UnknownField::fixed64_size () const {return fixed64_.size();} -inline int UnknownField::length_delimited_size() const { - return length_delimited_.size(); +inline UnknownField::Type UnknownField::type() const { + return static_cast<Type>(type_); } -inline int UnknownField::group_size () const {return group_.size();} -inline uint64 UnknownField::varint (int index) const { - return varint_.Get(index); -} -inline uint32 UnknownField::fixed32(int index) const { - return fixed32_.Get(index); -} -inline uint64 UnknownField::fixed64(int index) const { - return fixed64_.Get(index); -} -inline const string& UnknownField::length_delimited(int index) const { - return length_delimited_.Get(index); -} -inline const UnknownFieldSet& UnknownField::group(int index) const { - return group_.Get(index); -} - -inline void UnknownField::set_varint (int index, uint64 value) { - varint_.Set(index, value); -} -inline void UnknownField::set_fixed32(int index, uint32 value) { - fixed32_.Set(index, value); -} -inline void UnknownField::set_fixed64(int index, uint64 value) { - fixed64_.Set(index, value); -} -inline void UnknownField::set_length_delimited(int index, const string& value) { - length_delimited_.Mutable(index)->assign(value); -} -inline string* UnknownField::mutable_length_delimited(int index) { - return length_delimited_.Mutable(index); -} -inline UnknownFieldSet* UnknownField::mutable_group(int index) { - return group_.Mutable(index); -} - -inline void UnknownField::add_varint (uint64 value) { - varint_.Add(value); -} -inline void UnknownField::add_fixed32(uint32 value) { - fixed32_.Add(value); -} -inline void UnknownField::add_fixed64(uint64 value) { - fixed64_.Add(value); -} -inline void UnknownField::add_length_delimited(const string& value) { - length_delimited_.Add()->assign(value); -} -inline string* UnknownField::add_length_delimited() { - return length_delimited_.Add(); -} -inline UnknownFieldSet* UnknownField::add_group() { - return group_.Add(); -} - -inline void UnknownField::clear_varint () { varint_.Clear(); } -inline void UnknownField::clear_fixed32() { fixed32_.Clear(); } -inline void UnknownField::clear_fixed64() { fixed64_.Clear(); } -inline void UnknownField::clear_length_delimited() { - length_delimited_.Clear(); -} -inline void UnknownField::clear_group() { group_.Clear(); } - -inline const RepeatedField<uint64>& UnknownField::varint () const { +inline uint64 UnknownField::varint () const { + GOOGLE_DCHECK_EQ(type_, TYPE_VARINT); return varint_; } -inline const RepeatedField<uint32>& UnknownField::fixed32() const { +inline uint32 UnknownField::fixed32() const { + GOOGLE_DCHECK_EQ(type_, TYPE_FIXED32); return fixed32_; } -inline const RepeatedField<uint64>& UnknownField::fixed64() const { +inline uint64 UnknownField::fixed64() const { + GOOGLE_DCHECK_EQ(type_, TYPE_FIXED64); return fixed64_; } -inline const RepeatedPtrField<string>& UnknownField::length_delimited() const { - return length_delimited_; +inline const string& UnknownField::length_delimited() const { + GOOGLE_DCHECK_EQ(type_, TYPE_LENGTH_DELIMITED); + return *length_delimited_; } -inline const RepeatedPtrField<UnknownFieldSet>& UnknownField::group() const { - return group_; +inline const UnknownFieldSet& UnknownField::group() const { + GOOGLE_DCHECK_EQ(type_, TYPE_GROUP); + return *group_; } -inline RepeatedField<uint64>* UnknownField::mutable_varint () { - return &varint_; +inline void UnknownField::set_varint(uint64 value) { + GOOGLE_DCHECK_EQ(type_, TYPE_VARINT); + varint_ = value; } -inline RepeatedField<uint32>* UnknownField::mutable_fixed32() { - return &fixed32_; +inline void UnknownField::set_fixed32(uint32 value) { + GOOGLE_DCHECK_EQ(type_, TYPE_FIXED32); + fixed32_ = value; } -inline RepeatedField<uint64>* UnknownField::mutable_fixed64() { - return &fixed64_; +inline void UnknownField::set_fixed64(uint64 value) { + GOOGLE_DCHECK_EQ(type_, TYPE_FIXED64); + fixed64_ = value; } -inline RepeatedPtrField<string>* UnknownField::mutable_length_delimited() { - return &length_delimited_; +inline void UnknownField::set_length_delimited(const string& value) { + GOOGLE_DCHECK_EQ(type_, TYPE_LENGTH_DELIMITED); + length_delimited_->assign(value); } -inline RepeatedPtrField<UnknownFieldSet>* UnknownField::mutable_group() { - return &group_; +inline string* UnknownField::mutable_length_delimited() { + GOOGLE_DCHECK_EQ(type_, TYPE_LENGTH_DELIMITED); + return length_delimited_; +} +inline UnknownFieldSet* UnknownField::mutable_group() { + GOOGLE_DCHECK_EQ(type_, TYPE_GROUP); + return group_; } } // namespace protobuf |