Revert https://codereview.chromium.org/1291903002 (protobuf roll).

third_party/protobuf/src/google/protobuf/message.h

 // Protocol Buffers - Google's data interchange format
 // Copyright 2008 Google Inc.  All rights reserved.
-// https://developers.google.com/protocol-buffers/
+// 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
@@ skipping 77 matching lines @@
 //                                            FindFieldByName("numbers");
 //     assert(numbers_field != NULL);
 //     assert(numbers_field->type() == FieldDescriptor::TYPE_INT32);
 //     assert(numbers_field->label() == FieldDescriptor::LABEL_REPEATED);
 //
 //     // Parse the message.
 //     foo->ParseFromString(data);
 //
 //     // Use the reflection interface to examine the contents.
 //     const Reflection* reflection = foo->GetReflection();
-//     assert(reflection->GetString(*foo, text_field) == "Hello World!");
-//     assert(reflection->FieldSize(*foo, numbers_field) == 3);
-//     assert(reflection->GetRepeatedInt32(*foo, numbers_field, 0) == 1);
-//     assert(reflection->GetRepeatedInt32(*foo, numbers_field, 1) == 5);
-//     assert(reflection->GetRepeatedInt32(*foo, numbers_field, 2) == 42);
+//     assert(reflection->GetString(foo, text_field) == "Hello World!");
+//     assert(reflection->FieldSize(foo, numbers_field) == 3);
+//     assert(reflection->GetRepeatedInt32(foo, numbers_field, 0) == 1);
+//     assert(reflection->GetRepeatedInt32(foo, numbers_field, 1) == 5);
+//     assert(reflection->GetRepeatedInt32(foo, numbers_field, 2) == 42);
 //
 //     delete foo;
 //   }
 
 #ifndef GOOGLE_PROTOBUF_MESSAGE_H__
 #define GOOGLE_PROTOBUF_MESSAGE_H__
 
+#include <vector>
+#include <string>
+
+#ifdef __DECCXX
+// HP C++'s iosfwd doesn't work.
+#include <iostream>
+#else
 #include <iosfwd>
-#include <string>
-#include <google/protobuf/stubs/type_traits.h>
-#include <vector>
+#endif
 
-#include <google/protobuf/arena.h>
 #include <google/protobuf/message_lite.h>
 
 #include <google/protobuf/stubs/common.h>
 #include <google/protobuf/descriptor.h>
 
 
-#define GOOGLE_PROTOBUF_HAS_ONEOF
-#define GOOGLE_PROTOBUF_HAS_ARENAS
-
 namespace google {
 namespace protobuf {
 
 // Defined in this file.
 class Message;
 class Reflection;
 class MessageFactory;
 
 // Defined in other files.
 class UnknownFieldSet;         // unknown_field_set.h
@@ skipping 32 matching lines @@
   inline Message() {}
   virtual ~Message();
 
   // Basic Operations ------------------------------------------------
 
   // Construct a new instance of the same type.  Ownership is passed to the
   // caller.  (This is also defined in MessageLite, but is defined again here
   // for return-type covariance.)
   virtual Message* New() const = 0;
 
-  // Construct a new instance on the arena. Ownership is passed to the caller
-  // if arena is a NULL. Default implementation allows for API compatibility
-  // during the Arena transition.
-  virtual Message* New(::google::protobuf::Arena* arena) const {
-    Message* message = New();
-    if (arena != NULL) {
-      arena->Own(message);
-    }
-    return message;
-  }
-
   // Make this message into a copy of the given message.  The given message
   // must have the same descriptor, but need not necessarily be the same class.
   // By default this is just implemented as "Clear(); MergeFrom(from);".
   virtual void CopyFrom(const Message& from);
 
   // Merge the fields from the given message into this message.  Singular
-  // fields will be overwritten, if specified in from, except for embedded
-  // messages which will be merged.  Repeated fields will be concatenated.
-  // The given message must be of the same type as this message (i.e. the
-  // exact same class).
+  // fields will be overwritten, except for embedded messages which will
+  // be merged.  Repeated fields will be concatenated.  The given message
+  // must be of the same type as this message (i.e. the exact same class).
   virtual void MergeFrom(const Message& from);
 
   // Verifies that IsInitialized() returns true.  GOOGLE_CHECK-fails otherwise, with
   // a nice error message.
   void CheckInitialized() const;
 
   // Slowly build a list of all required fields that are not set.
   // This is much, much slower than IsInitialized() as it is implemented
   // purely via reflection.  Generally, you should not call this unless you
   // have already determined that an error exists by calling IsInitialized().
-  void FindInitializationErrors(std::vector<string>* errors) const;
+  void FindInitializationErrors(vector<string>* errors) const;
 
   // Like FindInitializationErrors, but joins all the strings, delimited by
   // commas, and returns them.
   string InitializationErrorString() const;
 
   // Clears all unknown fields from this message and all embedded messages.
   // Normally, if unknown tag numbers are encountered when parsing a message,
   // the tag and value are stored in the message's UnknownFieldSet and
   // then written back out when the message is serialized.  This allows servers
   // which simply route messages to other servers to pass through messages
   // that have new field definitions which they don't yet know about.  However,
   // this behavior can have security implications.  To avoid it, call this
   // method after parsing.
   //
   // See Reflection::GetUnknownFields() for more on unknown fields.
   virtual void DiscardUnknownFields();
 
   // Computes (an estimate of) the total number of bytes currently used for
   // storing the message in memory.  The default implementation calls the
   // Reflection object's SpaceUsed() method.
-  //
-  // SpaceUsed() is noticeably slower than ByteSize(), as it is implemented
-  // using reflection (rather than the generated code implementation for
-  // ByteSize()). Like ByteSize(), its CPU time is linear in the number of
-  // fields defined for the proto.
   virtual int SpaceUsed() const;
 
   // Debugging & Testing----------------------------------------------
 
   // Generates a human readable form of this message, useful for debugging
   // and other purposes.
   string DebugString() const;
   // Like DebugString(), but with less whitespace.
   string ShortDebugString() const;
   // Like DebugString(), but do not escape UTF-8 byte sequences.
@@ skipping 78 matching lines @@
   // Get a struct containing the metadata for the Message. Most subclasses only
   // need to implement this method, rather than the GetDescriptor() and
   // GetReflection() wrappers.
   virtual Metadata GetMetadata() const  = 0;
 
 
  private:
   GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Message);
 };
 
-namespace internal {
-// Forward-declare interfaces used to implement RepeatedFieldRef.
-// These are protobuf internals that users shouldn't care about.
-class RepeatedFieldAccessor;
-}  // namespace internal
-
-// Forward-declare RepeatedFieldRef templates. The second type parameter is
-// used for SFINAE tricks. Users should ignore it.
-template<typename T, typename Enable = void>
-class RepeatedFieldRef;
-
-template<typename T, typename Enable = void>
-class MutableRepeatedFieldRef;
-
 // This interface contains methods that can be used to dynamically access
 // and modify the fields of a protocol message.  Their semantics are
 // similar to the accessors the protocol compiler generates.
 //
 // To get the Reflection for a given Message, call Message::GetReflection().
 //
 // This interface is separate from Message only for efficiency reasons;
 // the vast majority of implementations of Message will share the same
 // implementation of Reflection (GeneratedMessageReflection,
 // defined in generated_message.h), and all Messages of a particular class
@@ skipping 28 matching lines @@
 //
 // TODO(kenton):  Create a utility class which callers can use to read and
 //   write fields from a Reflection without paying attention to the type.
 class LIBPROTOBUF_EXPORT Reflection {
  public:
   inline Reflection() {}
   virtual ~Reflection();
 
   // Get the UnknownFieldSet for the message.  This contains fields which
   // were seen when the Message was parsed but were not recognized according
-  // to the Message's definition. For proto3 protos, this method will always
-  // return an empty UnknownFieldSet.
+  // to the Message's definition.
   virtual const UnknownFieldSet& GetUnknownFields(
       const Message& message) const = 0;
   // Get a mutable pointer to the UnknownFieldSet for the message.  This
   // contains fields which were seen when the Message was parsed but were not
-  // recognized according to the Message's definition. For proto3 protos, this
-  // method will return a valid mutable UnknownFieldSet pointer but modifying
-  // it won't affect the serialized bytes of the message.
+  // recognized according to the Message's definition.
   virtual UnknownFieldSet* MutableUnknownFields(Message* message) const = 0;
 
   // Estimate the amount of memory used by the message object.
   virtual int SpaceUsed(const Message& message) const = 0;
 
   // Check if the given non-repeated field is set.
   virtual bool HasField(const Message& message,
                         const FieldDescriptor* field) const = 0;
 
   // Get the number of elements of a repeated field.
   virtual int FieldSize(const Message& message,
                         const FieldDescriptor* field) const = 0;
 
   // Clear the value of a field, so that HasField() returns false or
   // FieldSize() returns zero.
   virtual void ClearField(Message* message,
                           const FieldDescriptor* field) const = 0;
 
-  // Check if the oneof is set. Returns true if any field in oneof
-  // is set, false otherwise.
-  // TODO(jieluo) - make it pure virtual after updating all
-  // the subclasses.
-  virtual bool HasOneof(const Message& /*message*/,
-                        const OneofDescriptor* /*oneof_descriptor*/) const {
-    return false;
-  }
-
-  virtual void ClearOneof(Message* /*message*/,
-                          const OneofDescriptor* /*oneof_descriptor*/) const {}
-
-  // Returns the field descriptor if the oneof is set. NULL otherwise.
-  // TODO(jieluo) - make it pure virtual.
-  virtual const FieldDescriptor* GetOneofFieldDescriptor(
-      const Message& /*message*/,
-      const OneofDescriptor* /*oneof_descriptor*/) const {
-    return NULL;
-  }
-
   // Removes the last element of a repeated field.
   // We don't provide a way to remove any element other than the last
   // because it invites inefficient use, such as O(n^2) filtering loops
   // that should have been O(n).  If you want to remove an element other
   // than the last, the best way to do it is to re-arrange the elements
   // (using Swap()) so that the one you want removed is at the end, then
   // call RemoveLast().
   virtual void RemoveLast(Message* message,
                           const FieldDescriptor* field) const = 0;
   // Removes the last element of a repeated message field, and returns the
   // pointer to the caller.  Caller takes ownership of the returned pointer.
   virtual Message* ReleaseLast(Message* message,
                                const FieldDescriptor* field) const = 0;
 
   // Swap the complete contents of two messages.
   virtual void Swap(Message* message1, Message* message2) const = 0;
 
-  // Swap fields listed in fields vector of two messages.
-  virtual void SwapFields(Message* message1,
-                          Message* message2,
-                          const std::vector<const FieldDescriptor*>& fields)
-      const = 0;
-
   // Swap two elements of a repeated field.
   virtual void SwapElements(Message* message,
-                            const FieldDescriptor* field,
-                            int index1,
-                            int index2) const = 0;
+                    const FieldDescriptor* field,
+                    int index1,
+                    int index2) const = 0;
 
   // List all fields of the message which are currently set.  This includes
   // extensions.  Singular fields will only be listed if HasField(field) would
   // return true and repeated fields will only be listed if FieldSize(field)
   // would return non-zero.  Fields (both normal fields and extension fields)
   // will be listed ordered by field number.
-  virtual void ListFields(
-      const Message& message,
-      std::vector<const FieldDescriptor*>* output) const = 0;
+  virtual void ListFields(const Message& message,
+                          vector<const FieldDescriptor*>* output) const = 0;
 
   // Singular field getters ------------------------------------------
   // These get the value of a non-repeated field.  They return the default
   // value for fields that aren't set.
 
   virtual int32  GetInt32 (const Message& message,
                            const FieldDescriptor* field) const = 0;
   virtual int64  GetInt64 (const Message& message,
                            const FieldDescriptor* field) const = 0;
   virtual uint32 GetUInt32(const Message& message,
                            const FieldDescriptor* field) const = 0;
   virtual uint64 GetUInt64(const Message& message,
                            const FieldDescriptor* field) const = 0;
   virtual float  GetFloat (const Message& message,
                            const FieldDescriptor* field) const = 0;
   virtual double GetDouble(const Message& message,
                            const FieldDescriptor* field) const = 0;
   virtual bool   GetBool  (const Message& message,
                            const FieldDescriptor* field) const = 0;
   virtual string GetString(const Message& message,
                            const FieldDescriptor* field) const = 0;
   virtual const EnumValueDescriptor* GetEnum(
       const Message& message, const FieldDescriptor* field) const = 0;
-
-  // GetEnumValue() returns an enum field's value as an integer rather than
-  // an EnumValueDescriptor*. If the integer value does not correspond to a
-  // known value descriptor, a new value descriptor is created. (Such a value
-  // will only be present when the new unknown-enum-value semantics are enabled
-  // for a message.)
-  virtual int GetEnumValue(
-      const Message& message, const FieldDescriptor* field) const;
-
   // See MutableMessage() for the meaning of the "factory" parameter.
   virtual const Message& GetMessage(const Message& message,
                                     const FieldDescriptor* field,
                                     MessageFactory* factory = NULL) const = 0;
 
   // Get a string value without copying, if possible.
   //
   // GetString() necessarily returns a copy of the string.  This can be
   // inefficient when the string is already stored in a string object in the
   // underlying message.  GetStringReference() will return a reference to the
   // underlying string in this case.  Otherwise, it will copy the string into
   // *scratch and return that.
   //
   // Note:  It is perfectly reasonable and useful to write code like:
   //     str = reflection->GetStringReference(field, &str);
   //   This line would ensure that only one copy of the string is made
   //   regardless of the field's underlying representation.  When initializing
   //   a newly-constructed string, though, it's just as fast and more readable
   //   to use code like:
-  //     string str = reflection->GetString(message, field);
+  //     string str = reflection->GetString(field);
   virtual const string& GetStringReference(const Message& message,
                                            const FieldDescriptor* field,
                                            string* scratch) const = 0;
 
 
   // Singular field mutators -----------------------------------------
   // These mutate the value of a non-repeated field.
 
   virtual void SetInt32 (Message* message,
                          const FieldDescriptor* field, int32  value) const = 0;
   virtual void SetInt64 (Message* message,
                          const FieldDescriptor* field, int64  value) const = 0;
   virtual void SetUInt32(Message* message,
                          const FieldDescriptor* field, uint32 value) const = 0;
   virtual void SetUInt64(Message* message,
                          const FieldDescriptor* field, uint64 value) const = 0;
   virtual void SetFloat (Message* message,
                          const FieldDescriptor* field, float  value) const = 0;
   virtual void SetDouble(Message* message,
                          const FieldDescriptor* field, double value) const = 0;
   virtual void SetBool  (Message* message,
                          const FieldDescriptor* field, bool   value) const = 0;
   virtual void SetString(Message* message,
                          const FieldDescriptor* field,
                          const string& value) const = 0;
   virtual void SetEnum  (Message* message,
                          const FieldDescriptor* field,
                          const EnumValueDescriptor* value) const = 0;
-  // Set an enum field's value with an integer rather than EnumValueDescriptor.
-  // If the value does not correspond to a known enum value, either behavior is
-  // undefined (for proto2 messages), or the value is accepted silently for
-  // messages with new unknown-enum-value semantics.
-  virtual void SetEnumValue(Message* message,
-                            const FieldDescriptor* field,
-                            int value) const;
-
   // Get a mutable pointer to a field with a message type.  If a MessageFactory
   // is provided, it will be used to construct instances of the sub-message;
   // otherwise, the default factory is used.  If the field is an extension that
   // does not live in the same pool as the containing message's descriptor (e.g.
   // it lives in an overlay pool), then a MessageFactory must be provided.
   // If you have no idea what that meant, then you probably don't need to worry
   // about it (don't provide a MessageFactory).  WARNING:  If the
   // FieldDescriptor is for a compiled-in extension, then
   // factory->GetPrototype(field->message_type() MUST return an instance of the
   // compiled-in class for this type, NOT DynamicMessage.
   virtual Message* MutableMessage(Message* message,
                                   const FieldDescriptor* field,
                                   MessageFactory* factory = NULL) const = 0;
-  // Replaces the message specified by 'field' with the already-allocated object
-  // sub_message, passing ownership to the message.  If the field contained a
-  // message, that message is deleted.  If sub_message is NULL, the field is
-  // cleared.
-  virtual void SetAllocatedMessage(Message* message,
-                                   Message* sub_message,
-                                   const FieldDescriptor* field) const = 0;
   // Releases the message specified by 'field' and returns the pointer,
   // ReleaseMessage() will return the message the message object if it exists.
   // Otherwise, it may or may not return NULL.  In any case, if the return value
   // is non-NULL, the caller takes ownership of the pointer.
   // If the field existed (HasField() is true), then the returned pointer will
   // be the same as the pointer returned by MutableMessage().
   // This function has the same effect as ClearField().
   virtual Message* ReleaseMessage(Message* message,
                                   const FieldDescriptor* field,
                                   MessageFactory* factory = NULL) const = 0;
@@ skipping 22 matching lines @@
                                    int index) const = 0;
   virtual bool   GetRepeatedBool  (const Message& message,
                                    const FieldDescriptor* field,
                                    int index) const = 0;
   virtual string GetRepeatedString(const Message& message,
                                    const FieldDescriptor* field,
                                    int index) const = 0;
   virtual const EnumValueDescriptor* GetRepeatedEnum(
       const Message& message,
       const FieldDescriptor* field, int index) const = 0;
-  // GetRepeatedEnumValue() returns an enum field's value as an integer rather
-  // than an EnumValueDescriptor*. If the integer value does not correspond to a
-  // known value descriptor, a new value descriptor is created. (Such a value
-  // will only be present when the new unknown-enum-value semantics are enabled
-  // for a message.)
-  virtual int GetRepeatedEnumValue(
-      const Message& message,
-      const FieldDescriptor* field, int index) const;
   virtual const Message& GetRepeatedMessage(
       const Message& message,
       const FieldDescriptor* field, int index) const = 0;
 
   // See GetStringReference(), above.
   virtual const string& GetRepeatedStringReference(
       const Message& message, const FieldDescriptor* field,
       int index, string* scratch) const = 0;
 
 
@@ skipping 20 matching lines @@
                                  int index, double value) const = 0;
   virtual void SetRepeatedBool  (Message* message,
                                  const FieldDescriptor* field,
                                  int index, bool   value) const = 0;
   virtual void SetRepeatedString(Message* message,
                                  const FieldDescriptor* field,
                                  int index, const string& value) const = 0;
   virtual void SetRepeatedEnum(Message* message,
                                const FieldDescriptor* field, int index,
                                const EnumValueDescriptor* value) const = 0;
-  // Set an enum field's value with an integer rather than EnumValueDescriptor.
-  // If the value does not correspond to a known enum value, either behavior is
-  // undefined (for proto2 messages), or the value is accepted silently for
-  // messages with new unknown-enum-value semantics.
-  virtual void SetRepeatedEnumValue(Message* message,
-                                    const FieldDescriptor* field, int index,
-                                    int value) const;
   // Get a mutable pointer to an element of a repeated field with a message
   // type.
   virtual Message* MutableRepeatedMessage(
       Message* message, const FieldDescriptor* field, int index) const = 0;
 
 
   // Repeated field adders -------------------------------------------
   // These add an element to a repeated field.
 
   virtual void AddInt32 (Message* message,
                          const FieldDescriptor* field, int32  value) const = 0;
   virtual void AddInt64 (Message* message,
                          const FieldDescriptor* field, int64  value) const = 0;
   virtual void AddUInt32(Message* message,
                          const FieldDescriptor* field, uint32 value) const = 0;
   virtual void AddUInt64(Message* message,
                          const FieldDescriptor* field, uint64 value) const = 0;
   virtual void AddFloat (Message* message,
                          const FieldDescriptor* field, float  value) const = 0;
   virtual void AddDouble(Message* message,
                          const FieldDescriptor* field, double value) const = 0;
   virtual void AddBool  (Message* message,
                          const FieldDescriptor* field, bool   value) const = 0;
   virtual void AddString(Message* message,
                          const FieldDescriptor* field,
                          const string& value) const = 0;
   virtual void AddEnum  (Message* message,
                          const FieldDescriptor* field,
                          const EnumValueDescriptor* value) const = 0;
-  // Set an enum field's value with an integer rather than EnumValueDescriptor.
-  // If the value does not correspond to a known enum value, either behavior is
-  // undefined (for proto2 messages), or the value is accepted silently for
-  // messages with new unknown-enum-value semantics.
-  virtual void AddEnumValue(Message* message,
-                            const FieldDescriptor* field,
-                            int value) const;
   // See MutableMessage() for comments on the "factory" parameter.
   virtual Message* AddMessage(Message* message,
                               const FieldDescriptor* field,
                               MessageFactory* factory = NULL) const = 0;
 
 
-  // Get a RepeatedFieldRef object that can be used to read the underlying
-  // repeated field. The type parameter T must be set according to the
-  // field's cpp type. The following table shows the mapping from cpp type
-  // to acceptable T.
-  //
-  //   field->cpp_type()      T
-  //   CPPTYPE_INT32        int32
-  //   CPPTYPE_UINT32       uint32
-  //   CPPTYPE_INT64        int64
-  //   CPPTYPE_UINT64       uint64
-  //   CPPTYPE_DOUBLE       double
-  //   CPPTYPE_FLOAT        float
-  //   CPPTYPE_BOOL         bool
-  //   CPPTYPE_ENUM         generated enum type or int32
-  //   CPPTYPE_STRING       string
-  //   CPPTYPE_MESSAGE      generated message type or google::protobuf::Message
-  //
-  // A RepeatedFieldRef object can be copied and the resulted object will point
-  // to the same repeated field in the same message. The object can be used as
-  // long as the message is not destroyed.
-  //
-  // Note that to use this method users need to include the header file
-  // "google/protobuf/reflection.h" (which defines the RepeatedFieldRef
-  // class templates).
-  template<typename T>
-  RepeatedFieldRef<T> GetRepeatedFieldRef(
-      const Message& message, const FieldDescriptor* field) const;
-
-  // Like GetRepeatedFieldRef() but return an object that can also be used
-  // manipulate the underlying repeated field.
-  template<typename T>
-  MutableRepeatedFieldRef<T> GetMutableRepeatedFieldRef(
-      Message* message, const FieldDescriptor* field) const;
-
-  // DEPRECATED. Please use Get(Mutable)RepeatedFieldRef() for repeated field
-  // access. The following repeated field accesors will be removed in the
-  // future.
-  //
   // Repeated field accessors  -------------------------------------------------
   // The methods above, e.g. GetRepeatedInt32(msg, fd, index), provide singular
   // access to the data in a RepeatedField.  The methods below provide aggregate
   // access by exposing the RepeatedField object itself with the Message.
   // Applying these templates to inappropriate types will lead to an undefined
   // reference at link time (e.g. GetRepeatedField<***double>), or possibly a
   // template matching error at compile time (e.g. GetRepeatedPtrField<File>).
   //
   // Usage example: my_doubs = refl->GetRepeatedField<double>(msg, fd);
 
-  // DEPRECATED. Please use GetRepeatedFieldRef().
-  //
   // for T = Cord and all protobuf scalar types except enums.
   template<typename T>
   const RepeatedField<T>& GetRepeatedField(
       const Message&, const FieldDescriptor*) const;
 
-  // DEPRECATED. Please use GetMutableRepeatedFieldRef().
-  //
   // for T = Cord and all protobuf scalar types except enums.
   template<typename T>
   RepeatedField<T>* MutableRepeatedField(
       Message*, const FieldDescriptor*) const;
 
-  // DEPRECATED. Please use GetRepeatedFieldRef().
-  //
   // for T = string, google::protobuf::internal::StringPieceField
   //         google::protobuf::Message & descendants.
   template<typename T>
   const RepeatedPtrField<T>& GetRepeatedPtrField(
       const Message&, const FieldDescriptor*) const;
 
-  // DEPRECATED. Please use GetMutableRepeatedFieldRef().
-  //
   // for T = string, google::protobuf::internal::StringPieceField
   //         google::protobuf::Message & descendants.
   template<typename T>
   RepeatedPtrField<T>* MutableRepeatedPtrField(
       Message*, const FieldDescriptor*) const;
 
   // Extensions ----------------------------------------------------------------
 
   // Try to find an extension of this message type by fully-qualified field
   // name.  Returns NULL if no extension is known for this name or number.
   virtual const FieldDescriptor* FindKnownExtensionByName(
       const string& name) const = 0;
 
   // Try to find an extension of this message type by field number.
   // Returns NULL if no extension is known for this name or number.
   virtual const FieldDescriptor* FindKnownExtensionByNumber(
       int number) const = 0;
 
-  // Feature Flags -------------------------------------------------------------
-
-  // Does this message support storing arbitrary integer values in enum fields?
-  // If |true|, GetEnumValue/SetEnumValue and associated repeated-field versions
-  // take arbitrary integer values, and the legacy GetEnum() getter will
-  // dynamically create an EnumValueDescriptor for any integer value without
-  // one. If |false|, setting an unknown enum value via the integer-based
-  // setters results in undefined behavior (in practice, GOOGLE_DCHECK-fails).
-  //
-  // Generic code that uses reflection to handle messages with enum fields
-  // should check this flag before using the integer-based setter, and either
-  // downgrade to a compatible value or use the UnknownFieldSet if not. For
-  // example:
-  //
-  // int new_value = GetValueFromApplicationLogic();
-  // if (reflection->SupportsUnknownEnumValues()) {
-  //     reflection->SetEnumValue(message, field, new_value);
-  // } else {
-  //     if (field_descriptor->enum_type()->
-  //             FindValueByNumver(new_value) != NULL) {
-  //         reflection->SetEnumValue(message, field, new_value);
-  //     } else if (emit_unknown_enum_values) {
-  //         reflection->MutableUnknownFields(message)->AddVarint(
-  //             field->number(),
-  //             new_value);
-  //     } else {
-  //         // convert value to a compatible/default value.
-  //         new_value = CompatibleDowngrade(new_value);
-  //         reflection->SetEnumValue(message, field, new_value);
-  //     }
-  // }
-  virtual bool SupportsUnknownEnumValues() const { return false; }
-
-  // Returns the MessageFactory associated with this message.  This can be
-  // useful for determining if a message is a generated message or not, for
-  // example:
-  //
-  // if (message->GetReflection()->GetMessageFactory() ==
-  //     google::protobuf::MessageFactory::generated_factory()) {
-  //   // This is a generated message.
-  // }
-  //
-  // It can also be used to create more messages of this type, though
-  // Message::New() is an easier way to accomplish this.
-  virtual MessageFactory* GetMessageFactory() const;
-
   // ---------------------------------------------------------------------------
 
  protected:
   // Obtain a pointer to a Repeated Field Structure and do some type checking:
   //   on field->cpp_type(),
   //   on field->field_option().ctype() (if ctype >= 0)
   //   of field->message_type() (if message_type != NULL).
   // We use 1 routine rather than 4 (const vs mutable) x (scalar vs pointer).
   virtual void* MutableRawRepeatedField(
       Message* message, const FieldDescriptor* field, FieldDescriptor::CppType,
       int ctype, const Descriptor* message_type) const = 0;
 
-  // The following methods are used to implement (Mutable)RepeatedFieldRef.
-  // A Ref object will store a raw pointer to the repeated field data (obtained
-  // from RepeatedFieldData()) and a pointer to a Accessor (obtained from
-  // RepeatedFieldAccessor) which will be used to access the raw data.
-  //
-  // TODO(xiaofeng): Make these methods pure-virtual.
-
-  // Returns a raw pointer to the repeated field
-  //
-  // "cpp_type" and "message_type" are decuded from the type parameter T passed
-  // to Get(Mutable)RepeatedFieldRef. If T is a generated message type,
-  // "message_type" should be set to its descriptor. Otherwise "message_type"
-  // should be set to NULL. Implementations of this method should check whether
-  // "cpp_type"/"message_type" is consistent with the actual type of the field.
-  virtual void* RepeatedFieldData(
-      Message* message, const FieldDescriptor* field,
-      FieldDescriptor::CppType cpp_type,
-      const Descriptor* message_type) const;
-
-  // The returned pointer should point to a singleton instance which implements
-  // the RepeatedFieldAccessor interface.
-  virtual const internal::RepeatedFieldAccessor* RepeatedFieldAccessor(
-      const FieldDescriptor* field) const;
-
  private:
-  template<typename T, typename Enable>
-  friend class RepeatedFieldRef;
-  template<typename T, typename Enable>
-  friend class MutableRepeatedFieldRef;
-
   // Special version for specialized implementations of string.  We can't call
   // MutableRawRepeatedField directly here because we don't have access to
   // FieldOptions::* which are defined in descriptor.pb.h.  Including that
   // file here is not possible because it would cause a circular include cycle.
   void* MutableRawRepeatedString(
       Message* message, const FieldDescriptor* field, bool is_string) const;
 
   GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Reflection);
 };
 
 // Abstract interface for a factory for message objects.
 class LIBPROTOBUF_EXPORT MessageFactory {
  public:
   inline MessageFactory() {}
   virtual ~MessageFactory();
 
   // Given a Descriptor, gets or constructs the default (prototype) Message
   // of that type.  You can then call that message's New() method to construct
   // a mutable message of that type.
   //
   // Calling this method twice with the same Descriptor returns the same
   // object.  The returned object remains property of the factory.  Also, any
   // objects created by calling the prototype's New() method share some data
-  // with the prototype, so these must be destroyed before the MessageFactory
+  // with the prototype, so these must be destoyed before the MessageFactory
   // is destroyed.
   //
   // The given descriptor must outlive the returned message, and hence must
   // outlive the MessageFactory.
   //
   // Some implementations do not support all types.  GetPrototype() will
   // return NULL if the descriptor passed in is not supported.
   //
   // This method may or may not be thread-safe depending on the implementation.
   // Each implementation should document its own degree thread-safety.
@@ skipping 110 matching lines @@
 }
 
 template<typename PB>
 inline RepeatedPtrField<PB>* Reflection::MutableRepeatedPtrField(
     Message* message, const FieldDescriptor* field) const {
   return static_cast<RepeatedPtrField<PB>* >(
       MutableRawRepeatedField(message, field,
           FieldDescriptor::CPPTYPE_MESSAGE, -1,
           PB::default_instance().GetDescriptor()));
 }
+
 }  // namespace protobuf
 
 }  // namespace google
 #endif  // GOOGLE_PROTOBUF_MESSAGE_H__