/thirdparty/breakpad/third_party/protobuf/protobuf/src/google/protobuf/extension_set.h
http://github.com/tomahawk-player/tomahawk · C++ Header · 904 lines · 543 code · 102 blank · 259 comment · 0 complexity · fe3ad94e16def7dbbde450b880b449c8 MD5 · raw file
- // 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.
- //
- // This header is logically internal, but is made public because it is used
- // from protocol-compiler-generated code, which may reside in other components.
- #ifndef GOOGLE_PROTOBUF_EXTENSION_SET_H__
- #define GOOGLE_PROTOBUF_EXTENSION_SET_H__
- #include <vector>
- #include <map>
- #include <utility>
- #include <string>
- #include <google/protobuf/stubs/common.h>
- namespace google {
- namespace protobuf {
- class Descriptor; // descriptor.h
- class FieldDescriptor; // descriptor.h
- class DescriptorPool; // descriptor.h
- class MessageLite; // message_lite.h
- class Message; // message.h
- class MessageFactory; // message.h
- class UnknownFieldSet; // unknown_field_set.h
- namespace io {
- class CodedInputStream; // coded_stream.h
- class CodedOutputStream; // coded_stream.h
- }
- namespace internal {
- class FieldSkipper; // wire_format_lite.h
- class RepeatedPtrFieldBase; // repeated_field.h
- }
- template <typename Element> class RepeatedField; // repeated_field.h
- template <typename Element> class RepeatedPtrField; // repeated_field.h
- }
- namespace protobuf {
- namespace internal {
- // Used to store values of type WireFormatLite::FieldType without having to
- // #include wire_format_lite.h. Also, ensures that we use only one byte to
- // store these values, which is important to keep the layout of
- // ExtensionSet::Extension small.
- typedef uint8 FieldType;
- // A function which, given an integer value, returns true if the number
- // matches one of the defined values for the corresponding enum type. This
- // is used with RegisterEnumExtension, below.
- typedef bool EnumValidityFunc(int number);
- // Version of the above which takes an argument. This is needed to deal with
- // extensions that are not compiled in.
- typedef bool EnumValidityFuncWithArg(const void* arg, int number);
- // Information about a registered extension.
- struct ExtensionInfo {
- inline ExtensionInfo() {}
- inline ExtensionInfo(FieldType type, bool is_repeated, bool is_packed)
- : type(type), is_repeated(is_repeated), is_packed(is_packed),
- descriptor(NULL) {}
- FieldType type;
- bool is_repeated;
- bool is_packed;
- struct EnumValidityCheck {
- EnumValidityFuncWithArg* func;
- const void* arg;
- };
- union {
- EnumValidityCheck enum_validity_check;
- const MessageLite* message_prototype;
- };
- // The descriptor for this extension, if one exists and is known. May be
- // NULL. Must not be NULL if the descriptor for the extension does not
- // live in the same pool as the descriptor for the containing type.
- const FieldDescriptor* descriptor;
- };
- // Abstract interface for an object which looks up extension definitions. Used
- // when parsing.
- class LIBPROTOBUF_EXPORT ExtensionFinder {
- public:
- virtual ~ExtensionFinder();
- // Find the extension with the given containing type and number.
- virtual bool Find(int number, ExtensionInfo* output) = 0;
- };
- // Implementation of ExtensionFinder which finds extensions defined in .proto
- // files which have been compiled into the binary.
- class LIBPROTOBUF_EXPORT GeneratedExtensionFinder : public ExtensionFinder {
- public:
- GeneratedExtensionFinder(const MessageLite* containing_type)
- : containing_type_(containing_type) {}
- virtual ~GeneratedExtensionFinder() {}
- // Returns true and fills in *output if found, otherwise returns false.
- virtual bool Find(int number, ExtensionInfo* output);
- private:
- const MessageLite* containing_type_;
- };
- // Note: extension_set_heavy.cc defines DescriptorPoolExtensionFinder for
- // finding extensions from a DescriptorPool.
- // This is an internal helper class intended for use within the protocol buffer
- // library and generated classes. Clients should not use it directly. Instead,
- // use the generated accessors such as GetExtension() of the class being
- // extended.
- //
- // This class manages extensions for a protocol message object. The
- // message's HasExtension(), GetExtension(), MutableExtension(), and
- // ClearExtension() methods are just thin wrappers around the embedded
- // ExtensionSet. When parsing, if a tag number is encountered which is
- // inside one of the message type's extension ranges, the tag is passed
- // off to the ExtensionSet for parsing. Etc.
- class LIBPROTOBUF_EXPORT ExtensionSet {
- public:
- ExtensionSet();
- ~ExtensionSet();
- // These are called at startup by protocol-compiler-generated code to
- // register known extensions. The registrations are used by ParseField()
- // to look up extensions for parsed field numbers. Note that dynamic parsing
- // does not use ParseField(); only protocol-compiler-generated parsing
- // methods do.
- static void RegisterExtension(const MessageLite* containing_type,
- int number, FieldType type,
- bool is_repeated, bool is_packed);
- static void RegisterEnumExtension(const MessageLite* containing_type,
- int number, FieldType type,
- bool is_repeated, bool is_packed,
- EnumValidityFunc* is_valid);
- static void RegisterMessageExtension(const MessageLite* containing_type,
- int number, FieldType type,
- bool is_repeated, bool is_packed,
- const MessageLite* prototype);
- // =================================================================
- // Add all fields which are currently present to the given vector. This
- // is useful to implement Reflection::ListFields().
- void AppendToList(const Descriptor* containing_type,
- const DescriptorPool* pool,
- vector<const FieldDescriptor*>* output) const;
- // =================================================================
- // Accessors
- //
- // Generated message classes include type-safe templated wrappers around
- // these methods. Generally you should use those rather than call these
- // directly, unless you are doing low-level memory management.
- //
- // When calling any of these accessors, the extension number requested
- // MUST exist in the DescriptorPool provided to the constructor. Otheriwse,
- // the method will fail an assert. Normally, though, you would not call
- // these directly; you would either call the generated accessors of your
- // message class (e.g. GetExtension()) or you would call the accessors
- // of the reflection interface. In both cases, it is impossible to
- // trigger this assert failure: the generated accessors only accept
- // linked-in extension types as parameters, while the Reflection interface
- // requires you to provide the FieldDescriptor describing the extension.
- //
- // When calling any of these accessors, a protocol-compiler-generated
- // implementation of the extension corresponding to the number MUST
- // be linked in, and the FieldDescriptor used to refer to it MUST be
- // the one generated by that linked-in code. Otherwise, the method will
- // die on an assert failure. The message objects returned by the message
- // accessors are guaranteed to be of the correct linked-in type.
- //
- // These methods pretty much match Reflection except that:
- // - They're not virtual.
- // - They identify fields by number rather than FieldDescriptors.
- // - They identify enum values using integers rather than descriptors.
- // - Strings provide Mutable() in addition to Set() accessors.
- bool Has(int number) const;
- int ExtensionSize(int number) const; // Size of a repeated extension.
- FieldType ExtensionType(int number) const;
- void ClearExtension(int number);
- // singular fields -------------------------------------------------
- int32 GetInt32 (int number, int32 default_value) const;
- int64 GetInt64 (int number, int64 default_value) const;
- uint32 GetUInt32(int number, uint32 default_value) const;
- uint64 GetUInt64(int number, uint64 default_value) const;
- float GetFloat (int number, float default_value) const;
- double GetDouble(int number, double default_value) const;
- bool GetBool (int number, bool default_value) const;
- int GetEnum (int number, int default_value) const;
- const string & GetString (int number, const string& default_value) const;
- const MessageLite& GetMessage(int number,
- const MessageLite& default_value) const;
- const MessageLite& GetMessage(int number, const Descriptor* message_type,
- MessageFactory* factory) const;
- // |descriptor| may be NULL so long as it is known that the descriptor for
- // the extension lives in the same pool as the descriptor for the containing
- // type.
- #define desc const FieldDescriptor* descriptor // avoid line wrapping
- void SetInt32 (int number, FieldType type, int32 value, desc);
- void SetInt64 (int number, FieldType type, int64 value, desc);
- void SetUInt32(int number, FieldType type, uint32 value, desc);
- void SetUInt64(int number, FieldType type, uint64 value, desc);
- void SetFloat (int number, FieldType type, float value, desc);
- void SetDouble(int number, FieldType type, double value, desc);
- void SetBool (int number, FieldType type, bool value, desc);
- void SetEnum (int number, FieldType type, int value, desc);
- void SetString(int number, FieldType type, const string& value, desc);
- string * MutableString (int number, FieldType type, desc);
- MessageLite* MutableMessage(int number, FieldType type,
- const MessageLite& prototype, desc);
- MessageLite* MutableMessage(const FieldDescriptor* decsriptor,
- MessageFactory* factory);
- #undef desc
- // repeated fields -------------------------------------------------
- int32 GetRepeatedInt32 (int number, int index) const;
- int64 GetRepeatedInt64 (int number, int index) const;
- uint32 GetRepeatedUInt32(int number, int index) const;
- uint64 GetRepeatedUInt64(int number, int index) const;
- float GetRepeatedFloat (int number, int index) const;
- double GetRepeatedDouble(int number, int index) const;
- bool GetRepeatedBool (int number, int index) const;
- int GetRepeatedEnum (int number, int index) const;
- const string & GetRepeatedString (int number, int index) const;
- const MessageLite& GetRepeatedMessage(int number, int index) const;
- void SetRepeatedInt32 (int number, int index, int32 value);
- void SetRepeatedInt64 (int number, int index, int64 value);
- void SetRepeatedUInt32(int number, int index, uint32 value);
- void SetRepeatedUInt64(int number, int index, uint64 value);
- void SetRepeatedFloat (int number, int index, float value);
- void SetRepeatedDouble(int number, int index, double value);
- void SetRepeatedBool (int number, int index, bool value);
- void SetRepeatedEnum (int number, int index, int value);
- void SetRepeatedString(int number, int index, const string& value);
- string * MutableRepeatedString (int number, int index);
- MessageLite* MutableRepeatedMessage(int number, int index);
- #define desc const FieldDescriptor* descriptor // avoid line wrapping
- void AddInt32 (int number, FieldType type, bool packed, int32 value, desc);
- void AddInt64 (int number, FieldType type, bool packed, int64 value, desc);
- void AddUInt32(int number, FieldType type, bool packed, uint32 value, desc);
- void AddUInt64(int number, FieldType type, bool packed, uint64 value, desc);
- void AddFloat (int number, FieldType type, bool packed, float value, desc);
- void AddDouble(int number, FieldType type, bool packed, double value, desc);
- void AddBool (int number, FieldType type, bool packed, bool value, desc);
- void AddEnum (int number, FieldType type, bool packed, int value, desc);
- void AddString(int number, FieldType type, const string& value, desc);
- string * AddString (int number, FieldType type, desc);
- MessageLite* AddMessage(int number, FieldType type,
- const MessageLite& prototype, desc);
- MessageLite* AddMessage(const FieldDescriptor* descriptor,
- MessageFactory* factory);
- #undef desc
- void RemoveLast(int number);
- void SwapElements(int number, int index1, int index2);
- // -----------------------------------------------------------------
- // TODO(kenton): Hardcore memory management accessors
- // =================================================================
- // convenience methods for implementing methods of Message
- //
- // These could all be implemented in terms of the other methods of this
- // class, but providing them here helps keep the generated code size down.
- void Clear();
- void MergeFrom(const ExtensionSet& other);
- void Swap(ExtensionSet* other);
- bool IsInitialized() const;
- // Parses a single extension from the input. The input should start out
- // positioned immediately after the tag. |containing_type| is the default
- // instance for the containing message; it is used only to look up the
- // extension by number. See RegisterExtension(), above. Unlike the other
- // methods of ExtensionSet, this only works for generated message types --
- // it looks up extensions registered using RegisterExtension().
- bool ParseField(uint32 tag, io::CodedInputStream* input,
- ExtensionFinder* extension_finder,
- FieldSkipper* field_skipper);
- // Specific versions for lite or full messages (constructs the appropriate
- // FieldSkipper automatically).
- bool ParseField(uint32 tag, io::CodedInputStream* input,
- const MessageLite* containing_type);
- bool ParseField(uint32 tag, io::CodedInputStream* input,
- const Message* containing_type,
- UnknownFieldSet* unknown_fields);
- // Parse an entire message in MessageSet format. Such messages have no
- // fields, only extensions.
- bool ParseMessageSet(io::CodedInputStream* input,
- ExtensionFinder* extension_finder,
- FieldSkipper* field_skipper);
- // Specific versions for lite or full messages (constructs the appropriate
- // FieldSkipper automatically).
- bool ParseMessageSet(io::CodedInputStream* input,
- const MessageLite* containing_type);
- bool ParseMessageSet(io::CodedInputStream* input,
- const Message* containing_type,
- UnknownFieldSet* unknown_fields);
- // Write all extension fields with field numbers in the range
- // [start_field_number, end_field_number)
- // to the output stream, using the cached sizes computed when ByteSize() was
- // last called. Note that the range bounds are inclusive-exclusive.
- void SerializeWithCachedSizes(int start_field_number,
- int end_field_number,
- io::CodedOutputStream* output) const;
- // Same as SerializeWithCachedSizes, but without any bounds checking.
- // The caller must ensure that target has sufficient capacity for the
- // serialized extensions.
- //
- // Returns a pointer past the last written byte.
- uint8* SerializeWithCachedSizesToArray(int start_field_number,
- int end_field_number,
- uint8* target) const;
- // Like above but serializes in MessageSet format.
- void SerializeMessageSetWithCachedSizes(io::CodedOutputStream* output) const;
- uint8* SerializeMessageSetWithCachedSizesToArray(uint8* target) const;
- // Returns the total serialized size of all the extensions.
- int ByteSize() const;
- // Like ByteSize() but uses MessageSet format.
- int MessageSetByteSize() const;
- // Returns (an estimate of) the total number of bytes used for storing the
- // extensions in memory, excluding sizeof(*this). If the ExtensionSet is
- // for a lite message (and thus possibly contains lite messages), the results
- // are undefined (might work, might crash, might corrupt data, might not even
- // be linked in). It's up to the protocol compiler to avoid calling this on
- // such ExtensionSets (easy enough since lite messages don't implement
- // SpaceUsed()).
- int SpaceUsedExcludingSelf() const;
- private:
- struct Extension {
- union {
- int32 int32_value;
- int64 int64_value;
- uint32 uint32_value;
- uint64 uint64_value;
- float float_value;
- double double_value;
- bool bool_value;
- int enum_value;
- string* string_value;
- MessageLite* message_value;
- RepeatedField <int32 >* repeated_int32_value;
- RepeatedField <int64 >* repeated_int64_value;
- RepeatedField <uint32 >* repeated_uint32_value;
- RepeatedField <uint64 >* repeated_uint64_value;
- RepeatedField <float >* repeated_float_value;
- RepeatedField <double >* repeated_double_value;
- RepeatedField <bool >* repeated_bool_value;
- RepeatedField <int >* repeated_enum_value;
- RepeatedPtrField<string >* repeated_string_value;
- RepeatedPtrField<MessageLite>* repeated_message_value;
- };
- FieldType type;
- bool is_repeated;
- // For singular types, indicates if the extension is "cleared". This
- // happens when an extension is set and then later cleared by the caller.
- // We want to keep the Extension object around for reuse, so instead of
- // removing it from the map, we just set is_cleared = true. This has no
- // meaning for repeated types; for those, the size of the RepeatedField
- // simply becomes zero when cleared.
- bool is_cleared;
- // For repeated types, this indicates if the [packed=true] option is set.
- bool is_packed;
- // The descriptor for this extension, if one exists and is known. May be
- // NULL. Must not be NULL if the descriptor for the extension does not
- // live in the same pool as the descriptor for the containing type.
- const FieldDescriptor* descriptor;
- // For packed fields, the size of the packed data is recorded here when
- // ByteSize() is called then used during serialization.
- // TODO(kenton): Use atomic<int> when C++ supports it.
- mutable int cached_size;
- // Some helper methods for operations on a single Extension.
- void SerializeFieldWithCachedSizes(
- int number,
- io::CodedOutputStream* output) const;
- uint8* SerializeFieldWithCachedSizesToArray(
- int number,
- uint8* target) const;
- void SerializeMessageSetItemWithCachedSizes(
- int number,
- io::CodedOutputStream* output) const;
- uint8* SerializeMessageSetItemWithCachedSizesToArray(
- int number,
- uint8* target) const;
- int ByteSize(int number) const;
- int MessageSetItemByteSize(int number) const;
- void Clear();
- int GetSize() const;
- void Free();
- int SpaceUsedExcludingSelf() const;
- };
- // Gets the extension with the given number, creating it if it does not
- // already exist. Returns true if the extension did not already exist.
- bool MaybeNewExtension(int number, const FieldDescriptor* descriptor,
- Extension** result);
- // Parse a single MessageSet item -- called just after the item group start
- // tag has been read.
- bool ParseMessageSetItem(io::CodedInputStream* input,
- ExtensionFinder* extension_finder,
- FieldSkipper* field_skipper);
- // Hack: RepeatedPtrFieldBase declares ExtensionSet as a friend. This
- // friendship should automatically extend to ExtensionSet::Extension, but
- // unfortunately some older compilers (e.g. GCC 3.4.4) do not implement this
- // correctly. So, we must provide helpers for calling methods of that
- // class.
- // Defined in extension_set_heavy.cc.
- static inline int RepeatedMessage_SpaceUsedExcludingSelf(
- RepeatedPtrFieldBase* field);
- // The Extension struct is small enough to be passed by value, so we use it
- // directly as the value type in the map rather than use pointers. We use
- // a map rather than hash_map here because we expect most ExtensionSets will
- // only contain a small number of extensions whereas hash_map is optimized
- // for 100 elements or more. Also, we want AppendToList() to order fields
- // by field number.
- map<int, Extension> extensions_;
- GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ExtensionSet);
- };
- // These are just for convenience...
- inline void ExtensionSet::SetString(int number, FieldType type,
- const string& value,
- const FieldDescriptor* descriptor) {
- MutableString(number, type, descriptor)->assign(value);
- }
- inline void ExtensionSet::SetRepeatedString(int number, int index,
- const string& value) {
- MutableRepeatedString(number, index)->assign(value);
- }
- inline void ExtensionSet::AddString(int number, FieldType type,
- const string& value,
- const FieldDescriptor* descriptor) {
- AddString(number, type, descriptor)->assign(value);
- }
- // ===================================================================
- // Glue for generated extension accessors
- // -------------------------------------------------------------------
- // Template magic
- // First we have a set of classes representing "type traits" for different
- // field types. A type traits class knows how to implement basic accessors
- // for extensions of a particular type given an ExtensionSet. The signature
- // for a type traits class looks like this:
- //
- // class TypeTraits {
- // public:
- // typedef ? ConstType;
- // typedef ? MutableType;
- //
- // static inline ConstType Get(int number, const ExtensionSet& set);
- // static inline void Set(int number, ConstType value, ExtensionSet* set);
- // static inline MutableType Mutable(int number, ExtensionSet* set);
- //
- // // Variants for repeated fields.
- // static inline ConstType Get(int number, const ExtensionSet& set,
- // int index);
- // static inline void Set(int number, int index,
- // ConstType value, ExtensionSet* set);
- // static inline MutableType Mutable(int number, int index,
- // ExtensionSet* set);
- // static inline void Add(int number, ConstType value, ExtensionSet* set);
- // static inline MutableType Add(int number, ExtensionSet* set);
- // };
- //
- // Not all of these methods make sense for all field types. For example, the
- // "Mutable" methods only make sense for strings and messages, and the
- // repeated methods only make sense for repeated types. So, each type
- // traits class implements only the set of methods from this signature that it
- // actually supports. This will cause a compiler error if the user tries to
- // access an extension using a method that doesn't make sense for its type.
- // For example, if "foo" is an extension of type "optional int32", then if you
- // try to write code like:
- // my_message.MutableExtension(foo)
- // you will get a compile error because PrimitiveTypeTraits<int32> does not
- // have a "Mutable()" method.
- // -------------------------------------------------------------------
- // PrimitiveTypeTraits
- // Since the ExtensionSet has different methods for each primitive type,
- // we must explicitly define the methods of the type traits class for each
- // known type.
- template <typename Type>
- class PrimitiveTypeTraits {
- public:
- typedef Type ConstType;
- static inline ConstType Get(int number, const ExtensionSet& set,
- ConstType default_value);
- static inline void Set(int number, FieldType field_type,
- ConstType value, ExtensionSet* set);
- };
- template <typename Type>
- class RepeatedPrimitiveTypeTraits {
- public:
- typedef Type ConstType;
- static inline Type Get(int number, const ExtensionSet& set, int index);
- static inline void Set(int number, int index, Type value, ExtensionSet* set);
- static inline void Add(int number, FieldType field_type,
- bool is_packed, Type value, ExtensionSet* set);
- };
- #define PROTOBUF_DEFINE_PRIMITIVE_TYPE(TYPE, METHOD) \
- template<> inline TYPE PrimitiveTypeTraits<TYPE>::Get( \
- int number, const ExtensionSet& set, TYPE default_value) { \
- return set.Get##METHOD(number, default_value); \
- } \
- template<> inline void PrimitiveTypeTraits<TYPE>::Set( \
- int number, FieldType field_type, TYPE value, ExtensionSet* set) { \
- set->Set##METHOD(number, field_type, value, NULL); \
- } \
- \
- template<> inline TYPE RepeatedPrimitiveTypeTraits<TYPE>::Get( \
- int number, const ExtensionSet& set, int index) { \
- return set.GetRepeated##METHOD(number, index); \
- } \
- template<> inline void RepeatedPrimitiveTypeTraits<TYPE>::Set( \
- int number, int index, TYPE value, ExtensionSet* set) { \
- set->SetRepeated##METHOD(number, index, value); \
- } \
- template<> inline void RepeatedPrimitiveTypeTraits<TYPE>::Add( \
- int number, FieldType field_type, bool is_packed, \
- TYPE value, ExtensionSet* set) { \
- set->Add##METHOD(number, field_type, is_packed, value, NULL); \
- }
- PROTOBUF_DEFINE_PRIMITIVE_TYPE( int32, Int32)
- PROTOBUF_DEFINE_PRIMITIVE_TYPE( int64, Int64)
- PROTOBUF_DEFINE_PRIMITIVE_TYPE(uint32, UInt32)
- PROTOBUF_DEFINE_PRIMITIVE_TYPE(uint64, UInt64)
- PROTOBUF_DEFINE_PRIMITIVE_TYPE( float, Float)
- PROTOBUF_DEFINE_PRIMITIVE_TYPE(double, Double)
- PROTOBUF_DEFINE_PRIMITIVE_TYPE( bool, Bool)
- #undef PROTOBUF_DEFINE_PRIMITIVE_TYPE
- // -------------------------------------------------------------------
- // StringTypeTraits
- // Strings support both Set() and Mutable().
- class LIBPROTOBUF_EXPORT StringTypeTraits {
- public:
- typedef const string& ConstType;
- typedef string* MutableType;
- static inline const string& Get(int number, const ExtensionSet& set,
- ConstType default_value) {
- return set.GetString(number, default_value);
- }
- static inline void Set(int number, FieldType field_type,
- const string& value, ExtensionSet* set) {
- set->SetString(number, field_type, value, NULL);
- }
- static inline string* Mutable(int number, FieldType field_type,
- ExtensionSet* set) {
- return set->MutableString(number, field_type, NULL);
- }
- };
- class LIBPROTOBUF_EXPORT RepeatedStringTypeTraits {
- public:
- typedef const string& ConstType;
- typedef string* MutableType;
- static inline const string& Get(int number, const ExtensionSet& set,
- int index) {
- return set.GetRepeatedString(number, index);
- }
- static inline void Set(int number, int index,
- const string& value, ExtensionSet* set) {
- set->SetRepeatedString(number, index, value);
- }
- static inline string* Mutable(int number, int index, ExtensionSet* set) {
- return set->MutableRepeatedString(number, index);
- }
- static inline void Add(int number, FieldType field_type,
- bool /*is_packed*/, const string& value,
- ExtensionSet* set) {
- set->AddString(number, field_type, value, NULL);
- }
- static inline string* Add(int number, FieldType field_type,
- ExtensionSet* set) {
- return set->AddString(number, field_type, NULL);
- }
- };
- // -------------------------------------------------------------------
- // EnumTypeTraits
- // ExtensionSet represents enums using integers internally, so we have to
- // static_cast around.
- template <typename Type, bool IsValid(int)>
- class EnumTypeTraits {
- public:
- typedef Type ConstType;
- static inline ConstType Get(int number, const ExtensionSet& set,
- ConstType default_value) {
- return static_cast<Type>(set.GetEnum(number, default_value));
- }
- static inline void Set(int number, FieldType field_type,
- ConstType value, ExtensionSet* set) {
- GOOGLE_DCHECK(IsValid(value));
- set->SetEnum(number, field_type, value, NULL);
- }
- };
- template <typename Type, bool IsValid(int)>
- class RepeatedEnumTypeTraits {
- public:
- typedef Type ConstType;
- static inline ConstType Get(int number, const ExtensionSet& set, int index) {
- return static_cast<Type>(set.GetRepeatedEnum(number, index));
- }
- static inline void Set(int number, int index,
- ConstType value, ExtensionSet* set) {
- GOOGLE_DCHECK(IsValid(value));
- set->SetRepeatedEnum(number, index, value);
- }
- static inline void Add(int number, FieldType field_type,
- bool is_packed, ConstType value, ExtensionSet* set) {
- GOOGLE_DCHECK(IsValid(value));
- set->AddEnum(number, field_type, is_packed, value, NULL);
- }
- };
- // -------------------------------------------------------------------
- // MessageTypeTraits
- // ExtensionSet guarantees that when manipulating extensions with message
- // types, the implementation used will be the compiled-in class representing
- // that type. So, we can static_cast down to the exact type we expect.
- template <typename Type>
- class MessageTypeTraits {
- public:
- typedef const Type& ConstType;
- typedef Type* MutableType;
- static inline ConstType Get(int number, const ExtensionSet& set,
- ConstType default_value) {
- return static_cast<const Type&>(
- set.GetMessage(number, default_value));
- }
- static inline MutableType Mutable(int number, FieldType field_type,
- ExtensionSet* set) {
- return static_cast<Type*>(
- set->MutableMessage(number, field_type, Type::default_instance(), NULL));
- }
- };
- template <typename Type>
- class RepeatedMessageTypeTraits {
- public:
- typedef const Type& ConstType;
- typedef Type* MutableType;
- static inline ConstType Get(int number, const ExtensionSet& set, int index) {
- return static_cast<const Type&>(set.GetRepeatedMessage(number, index));
- }
- static inline MutableType Mutable(int number, int index, ExtensionSet* set) {
- return static_cast<Type*>(set->MutableRepeatedMessage(number, index));
- }
- static inline MutableType Add(int number, FieldType field_type,
- ExtensionSet* set) {
- return static_cast<Type*>(
- set->AddMessage(number, field_type, Type::default_instance(), NULL));
- }
- };
- // -------------------------------------------------------------------
- // ExtensionIdentifier
- // This is the type of actual extension objects. E.g. if you have:
- // extends Foo with optional int32 bar = 1234;
- // then "bar" will be defined in C++ as:
- // ExtensionIdentifier<Foo, PrimitiveTypeTraits<int32>, 1, false> bar(1234);
- //
- // Note that we could, in theory, supply the field number as a template
- // parameter, and thus make an instance of ExtensionIdentifier have no
- // actual contents. However, if we did that, then using at extension
- // identifier would not necessarily cause the compiler to output any sort
- // of reference to any simple defined in the extension's .pb.o file. Some
- // linkers will actually drop object files that are not explicitly referenced,
- // but that would be bad because it would cause this extension to not be
- // registered at static initialization, and therefore using it would crash.
- template <typename ExtendeeType, typename TypeTraitsType,
- FieldType field_type, bool is_packed>
- class ExtensionIdentifier {
- public:
- typedef TypeTraitsType TypeTraits;
- typedef ExtendeeType Extendee;
- ExtensionIdentifier(int number, typename TypeTraits::ConstType default_value)
- : number_(number), default_value_(default_value) {}
- inline int number() const { return number_; }
- typename TypeTraits::ConstType default_value() const {
- return default_value_;
- }
- private:
- const int number_;
- typename TypeTraits::ConstType default_value_;
- };
- // -------------------------------------------------------------------
- // Generated accessors
- // This macro should be expanded in the context of a generated type which
- // has extensions.
- //
- // We use "_proto_TypeTraits" as a type name below because "TypeTraits"
- // causes problems if the class has a nested message or enum type with that
- // name and "_TypeTraits" is technically reserved for the C++ library since
- // it starts with an underscore followed by a capital letter.
- #define GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(CLASSNAME) \
- /* Has, Size, Clear */ \
- template <typename _proto_TypeTraits, \
- ::google::protobuf::internal::FieldType field_type, \
- bool is_packed> \
- inline bool HasExtension( \
- const ::google::protobuf::internal::ExtensionIdentifier< \
- CLASSNAME, _proto_TypeTraits, field_type, is_packed>& id) const { \
- return _extensions_.Has(id.number()); \
- } \
- \
- template <typename _proto_TypeTraits, \
- ::google::protobuf::internal::FieldType field_type, \
- bool is_packed> \
- inline void ClearExtension( \
- const ::google::protobuf::internal::ExtensionIdentifier< \
- CLASSNAME, _proto_TypeTraits, field_type, is_packed>& id) { \
- _extensions_.ClearExtension(id.number()); \
- } \
- \
- template <typename _proto_TypeTraits, \
- ::google::protobuf::internal::FieldType field_type, \
- bool is_packed> \
- inline int ExtensionSize( \
- const ::google::protobuf::internal::ExtensionIdentifier< \
- CLASSNAME, _proto_TypeTraits, field_type, is_packed>& id) const { \
- return _extensions_.ExtensionSize(id.number()); \
- } \
- \
- /* Singular accessors */ \
- template <typename _proto_TypeTraits, \
- ::google::protobuf::internal::FieldType field_type, \
- bool is_packed> \
- inline typename _proto_TypeTraits::ConstType GetExtension( \
- const ::google::protobuf::internal::ExtensionIdentifier< \
- CLASSNAME, _proto_TypeTraits, field_type, is_packed>& id) const { \
- return _proto_TypeTraits::Get(id.number(), _extensions_, \
- id.default_value()); \
- } \
- \
- template <typename _proto_TypeTraits, \
- ::google::protobuf::internal::FieldType field_type, \
- bool is_packed> \
- inline typename _proto_TypeTraits::MutableType MutableExtension( \
- const ::google::protobuf::internal::ExtensionIdentifier< \
- CLASSNAME, _proto_TypeTraits, field_type, is_packed>& id) { \
- return _proto_TypeTraits::Mutable(id.number(), field_type, &_extensions_);\
- } \
- \
- template <typename _proto_TypeTraits, \
- ::google::protobuf::internal::FieldType field_type, \
- bool is_packed> \
- inline void SetExtension( \
- const ::google::protobuf::internal::ExtensionIdentifier< \
- CLASSNAME, _proto_TypeTraits, field_type, is_packed>& id, \
- typename _proto_TypeTraits::ConstType value) { \
- _proto_TypeTraits::Set(id.number(), field_type, value, &_extensions_); \
- } \
- \
- /* Repeated accessors */ \
- template <typename _proto_TypeTraits, \
- ::google::protobuf::internal::FieldType field_type, \
- bool is_packed> \
- inline typename _proto_TypeTraits::ConstType GetExtension( \
- const ::google::protobuf::internal::ExtensionIdentifier< \
- CLASSNAME, _proto_TypeTraits, field_type, is_packed>& id, \
- int index) const { \
- return _proto_TypeTraits::Get(id.number(), _extensions_, index); \
- } \
- \
- template <typename _proto_TypeTraits, \
- ::google::protobuf::internal::FieldType field_type, \
- bool is_packed> \
- inline typename _proto_TypeTraits::MutableType MutableExtension( \
- const ::google::protobuf::internal::ExtensionIdentifier< \
- CLASSNAME, _proto_TypeTraits, field_type, is_packed>& id, \
- int index) { \
- return _proto_TypeTraits::Mutable(id.number(), index, &_extensions_); \
- } \
- \
- template <typename _proto_TypeTraits, \
- ::google::protobuf::internal::FieldType field_type, \
- bool is_packed> \
- inline void SetExtension( \
- const ::google::protobuf::internal::ExtensionIdentifier< \
- CLASSNAME, _proto_TypeTraits, field_type, is_packed>& id, \
- int index, typename _proto_TypeTraits::ConstType value) { \
- _proto_TypeTraits::Set(id.number(), index, value, &_extensions_); \
- } \
- \
- template <typename _proto_TypeTraits, \
- ::google::protobuf::internal::FieldType field_type, \
- bool is_packed> \
- inline typename _proto_TypeTraits::MutableType AddExtension( \
- const ::google::protobuf::internal::ExtensionIdentifier< \
- CLASSNAME, _proto_TypeTraits, field_type, is_packed>& id) { \
- return _proto_TypeTraits::Add(id.number(), field_type, &_extensions_); \
- } \
- \
- template <typename _proto_TypeTraits, \
- ::google::protobuf::internal::FieldType field_type, \
- bool is_packed> \
- inline void AddExtension( \
- const ::google::protobuf::internal::ExtensionIdentifier< \
- CLASSNAME, _proto_TypeTraits, field_type, is_packed>& id, \
- typename _proto_TypeTraits::ConstType value) { \
- _proto_TypeTraits::Add(id.number(), field_type, is_packed, \
- value, &_extensions_); \
- }
- } // namespace internal
- } // namespace protobuf
- } // namespace google
- #endif // GOOGLE_PROTOBUF_EXTENSION_SET_H__