protobuf 2.8.0.beta9 → 2.8.0

data/ext/protobuf-2.4.1/src/google/protobuf/extension_set.h

@@ -1,904 +0,0 @@
-// 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__