Down-integrate from internal code base (C++ maps support).

1 files changed, 486 insertions, 0 deletions

diff --git a/src/google/protobuf/map_type_handler.h b/src/google/protobuf/map_type_handler.h
new file mode 100644
index 00000000..88a6d7b8
--- /dev/null
+++ b/src/google/protobuf/map_type_handler.h
@@ -0,0 +1,486 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// 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.
+
+#ifndef GOOGLE_PROTOBUF_TYPE_HANDLER_H__
+#define GOOGLE_PROTOBUF_TYPE_HANDLER_H__
+
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+
+namespace google {
+namespace protobuf {
+namespace internal {
+
+// Used for compile time type selection. MapIf::type will be TrueType if Flag is
+// true and FalseType otherwise.
+template<bool Flag, typename TrueType, typename FalseType>
+struct MapIf;
+
+template<typename TrueType, typename FalseType>
+struct MapIf<true, TrueType, FalseType> {
+  typedef TrueType type;
+};
+
+template<typename TrueType, typename FalseType>
+struct MapIf<false, TrueType, FalseType> {
+  typedef FalseType type;
+};
+
+// In MapField, string and message are stored as pointer while others are stored
+// as object. However, google::protobuf::Map has unified api. Functions in this class
+// convert key/value to type wanted in api regardless how it's stored
+// internally.
+template <typename Type>
+class MapCommonTypeHandler {
+ public:
+  static inline Type& Reference(Type* x) { return *x; }
+  static inline Type& Reference(Type& x) { return x; }
+  static inline const Type& Reference(const Type& x) { return x; }
+  static inline Type* Pointer(Type* x) { return x; }
+  static inline Type* Pointer(Type& x) { return &x; }
+  static inline const Type* Pointer(const Type* x) { return x; }
+  static inline const Type* Pointer(const Type& x) { return &x; }
+};
+
+// In proto2 Map, enum needs to be initialized to given default value, while
+// other types' default value can be inferred from the type.
+template <bool IsEnum, typename Type>
+class MapValueInitializer {
+ public:
+  static inline void Initialize(Type& type, int default_enum_value);
+};
+
+template <typename Type>
+class MapValueInitializer<true, Type> {
+ public:
+  static inline void Initialize(Type& value, int default_enum_value) {
+    value = static_cast<Type>(default_enum_value);
+  }
+};
+
+template <typename Type>
+class MapValueInitializer<false, Type> {
+ public:
+  static inline void Initialize(Type& value, int default_enum_value) {}
+};
+
+// Handlers for key/value stored type in MapField. ==================
+
+// Handler for message
+template <typename Type>
+class MapCppTypeHandler : public MapCommonTypeHandler<Type> {
+ public:
+  static const bool kIsStringOrMessage = true;
+  // SpaceUsedInMapEntry: Return bytes used by value in MapEntry, excluding
+  // those already calculate in sizeof(MapField).
+  static int SpaceUsedInMapEntry(const Type* value) {
+    return value->SpaceUsed();
+  }
+  // Return bytes used by value in Map.
+  static int SpaceUsedInMap(const Type& value) { return value.SpaceUsed(); }
+  static inline void Clear(Type** value) {
+    if (*value != NULL) (*value)->Type::Clear();
+  }
+  static inline void ClearMaybeByDefaultEnum(Type** value,
+                                             int default_enum_value) {
+    if (*value != NULL) (*value)->Type::Clear();
+  }
+  static inline void Merge(const Type& from, Type** to) {
+    (*to)->MergeFrom(from);
+  }
+
+  static void Delete(const Type* ptr) { delete ptr; }
+
+  // Assign default value to given instance.
+  static inline void AssignDefaultValue(Type** value) {
+    *value = const_cast<Type*>(&Type::default_instance());
+  }
+  // Initialize value when constructing MapEntry
+  static inline void Initialize(Type** x) { *x = NULL; }
+  // Same as above, but use default_enum_value to initialize enum type value.
+  static inline void InitializeMaybeByDefaultEnum(
+      Type** x, int default_enum_value) {
+    *x = NULL;
+  }
+  // Initialize value for the first time mutable accessor is called.
+  static inline void EnsureMutable(Type** value) {
+    if (*value == NULL) *value = new Type;
+  }
+  // Return default instance if value is not initialized when calling const
+  // reference accessor.
+  static inline const Type& DefaultIfNotInitialized(Type* value,
+                                                    Type* default_value) {
+    return value != NULL ? *value : *default_value;
+  }
+  // Check if all required fields have values set.
+  static inline bool IsInitialized(Type* value) {
+    return value->IsInitialized();
+  }
+};
+
+// Handler for string.
+template <>
+class MapCppTypeHandler<string> : public MapCommonTypeHandler<string> {
+ public:
+  static const bool kIsStringOrMessage = true;
+  static inline void Merge(const string& from, string** to) { **to = from; }
+  static inline void Clear(string** value) { (*value)->clear(); }
+  static inline void ClearMaybeByDefaultEnum(string** value, int default_enum) {
+    (*value)->clear();
+  }
+  static inline int SpaceUsedInMapEntry(const string* value) {
+    return sizeof(*value) + StringSpaceUsedExcludingSelf(*value);
+  }
+  static inline int SpaceUsedInMap(const string& value) {
+    return sizeof(value) + StringSpaceUsedExcludingSelf(value);
+  }
+  static void Delete(const string* ptr) {
+    if (ptr != &::google::protobuf::internal::GetEmptyString()) delete ptr;
+  }
+  static inline void AssignDefaultValue(string** value) {}
+  static inline void Initialize(string** value) {
+    *value = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
+  }
+  static inline void InitializeMaybeByDefaultEnum(
+      string** value, int default_enum_value) {
+    *value = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
+  }
+  static inline void EnsureMutable(string** value) {
+    if (*value == &::google::protobuf::internal::GetEmptyString()) *value = new string;
+  }
+  static inline const string& DefaultIfNotInitialized(string* value,
+                                                      string* default_value) {
+    return value != default_value ? *value : *default_value;
+  }
+  static inline bool IsInitialized(string* value) { return true; }
+};
+
+// Base class for primitive type handlers.
+template <typename Type>
+class MapPrimitiveTypeHandler : public MapCommonTypeHandler<Type> {
+ public:
+  static const bool kIsStringOrMessage = false;
+  static inline void Delete(const Type& x) {}
+  static inline void Merge(const Type& from, Type* to) { *to = from; }
+  static inline int SpaceUsedInMapEntry(const Type& value) { return 0; }
+  static inline int SpaceUsedInMap(const Type& value) { return sizeof(Type); }
+  static inline void AssignDefaultValue(Type* value) {}
+  static inline const Type& DefaultIfNotInitialized(
+      const Type& value, const Type& default_value) {
+    return value;
+  }
+  static inline bool IsInitialized(const Type& value) { return true; }
+};
+
+// Handlers for primitive types.
+#define PRIMITIVE_HANDLER(CType)                                              \
+  template <>                                                                 \
+  class MapCppTypeHandler<CType> : public MapPrimitiveTypeHandler<CType> {    \
+   public:                                                                    \
+    static inline void Clear(CType* value) { *value = 0; }                    \
+    static inline void ClearMaybeByDefaultEnum(CType* value,                  \
+                                               int default_enum_value) {      \
+      *value = static_cast<CType>(default_enum_value);                        \
+    }                                                                         \
+    static inline void Initialize(CType* value) { *value = 0; }               \
+    static inline void InitializeMaybeByDefaultEnum(CType* value,             \
+                                                    int default_enum_value) { \
+      *value = static_cast<CType>(default_enum_value);                        \
+    }                                                                         \
+    static inline void EnsureMutable(CType* value) {}                         \
+  };
+
+PRIMITIVE_HANDLER(int32 )
+PRIMITIVE_HANDLER(int64 )
+PRIMITIVE_HANDLER(uint32)
+PRIMITIVE_HANDLER(uint64)
+PRIMITIVE_HANDLER(double)
+PRIMITIVE_HANDLER(float )
+PRIMITIVE_HANDLER(bool  )
+
+#undef PRIMITIVE_HANDLER
+
+// Define constants for given proto field type
+template <FieldDescriptor::Type Type>
+class MapFieldTypeTraits {};
+
+#define TYPE_TRAITS(FieldType, CType, WireFormatType, IsMessage, IsEnum) \
+  template <>                                                            \
+  class MapFieldTypeTraits<FieldDescriptor::TYPE_##FieldType> {          \
+   public:                                                               \
+    typedef CType CppType;                                               \
+    static const bool kIsMessage = IsMessage;                            \
+    static const bool kIsEnum = IsEnum;                                  \
+    static const WireFormatLite::WireType kWireType =                    \
+        WireFormatLite::WIRETYPE_##WireFormatType;                       \
+  };
+
+TYPE_TRAITS(MESSAGE , Message,  LENGTH_DELIMITED, true, false)
+TYPE_TRAITS(STRING  , string ,  LENGTH_DELIMITED, false, false)
+TYPE_TRAITS(BYTES   , string ,  LENGTH_DELIMITED, false, false)
+TYPE_TRAITS(INT64   , int64  ,  VARINT , false, false)
+TYPE_TRAITS(UINT64  , uint64 ,  VARINT , false, false)
+TYPE_TRAITS(INT32   , int32  ,  VARINT , false, false)
+TYPE_TRAITS(UINT32  , uint32 ,  VARINT , false, false)
+TYPE_TRAITS(SINT64  , int64  ,  VARINT , false, false)
+TYPE_TRAITS(SINT32  , int32  ,  VARINT , false, false)
+TYPE_TRAITS(ENUM    , int    ,  VARINT , false, true )
+TYPE_TRAITS(DOUBLE  , double ,  FIXED64, false, false)
+TYPE_TRAITS(FLOAT   , float  ,  FIXED32, false, false)
+TYPE_TRAITS(FIXED64 , uint64 ,  FIXED64, false, false)
+TYPE_TRAITS(FIXED32 , uint32 ,  FIXED32, false, false)
+TYPE_TRAITS(SFIXED64, int64  ,  FIXED64, false, false)
+TYPE_TRAITS(SFIXED32, int32  ,  FIXED32, false, false)
+TYPE_TRAITS(BOOL    , bool   ,  VARINT , false, false)
+
+#undef TYPE_TRAITS
+
+// Handler for proto field type. Define types and constants used in compile
+// time. Also define functions used in parsing and serializing.
+template <FieldDescriptor::Type Type>
+class MapProtoTypeHandler {
+ public:
+  // Internal stored type in MapEntry for given proto field type.
+  typedef typename MapFieldTypeTraits<Type>::CppType CppType;
+
+  // Whether given type is a message.
+  static const bool kIsMessage = MapFieldTypeTraits<Type>::kIsMessage;
+
+  // Whether given type is an enum.
+  static const bool kIsEnum = MapFieldTypeTraits<Type>::kIsEnum;
+
+  // The wire type of given proto field type.
+  static const WireFormatLite::WireType kWireType =
+      MapFieldTypeTraits<Type>::kWireType;
+
+  // Functions used in parsing and serialization. ===================
+
+  template <typename ValueType>
+  static inline int ByteSize(const ValueType& value);
+  template <typename ValueType>
+  static inline int GetCachedSize(const ValueType& value);
+  static inline void Write(int field, const CppType& value,
+                           io::CodedOutputStream* output);
+  static inline uint8* WriteToArray(int field, const CppType& value,
+                                    uint8* output);
+  template <typename ValueType>
+  static inline bool Read(io::CodedInputStream* input, ValueType* value);
+};
+
+template <>
+template <typename ValueType>
+inline int MapProtoTypeHandler<FieldDescriptor::TYPE_MESSAGE>::ByteSize(
+    const ValueType& value) {
+  return WireFormatLite::MessageSizeNoVirtual(value);
+}
+
+#define BYTE_SIZE(FieldType, DeclaredType)                                     \
+  template <>                                                                  \
+  template <typename ValueType>                                                \
+  inline int MapProtoTypeHandler<FieldDescriptor::TYPE_##FieldType>::ByteSize( \
+      const ValueType& value) {                                                \
+    return WireFormatLite::DeclaredType##Size(value);                          \
+  }
+
+BYTE_SIZE(STRING, String)
+BYTE_SIZE(BYTES , Bytes)
+BYTE_SIZE(INT64 , Int64)
+BYTE_SIZE(UINT64, UInt64)
+BYTE_SIZE(INT32 , Int32)
+BYTE_SIZE(UINT32, UInt32)
+BYTE_SIZE(SINT64, SInt64)
+BYTE_SIZE(SINT32, SInt32)
+BYTE_SIZE(ENUM  , Enum)
+
+#undef BYTE_SIZE
+
+#define FIXED_BYTE_SIZE(FieldType, DeclaredType)                               \
+  template <>                                                                  \
+  template <typename ValueType>                                                \
+  inline int MapProtoTypeHandler<FieldDescriptor::TYPE_##FieldType>::ByteSize( \
+      const ValueType& value) {                                                \
+    return WireFormatLite::k##DeclaredType##Size;                              \
+  }
+
+FIXED_BYTE_SIZE(DOUBLE  , Double)
+FIXED_BYTE_SIZE(FLOAT   , Float)
+FIXED_BYTE_SIZE(FIXED64 , Fixed64)
+FIXED_BYTE_SIZE(FIXED32 , Fixed32)
+FIXED_BYTE_SIZE(SFIXED64, SFixed64)
+FIXED_BYTE_SIZE(SFIXED32, SFixed32)
+FIXED_BYTE_SIZE(BOOL    , Bool)
+
+#undef FIXED_BYTE_SIZE
+
+template <>
+template <typename ValueType>
+inline int MapProtoTypeHandler<FieldDescriptor::TYPE_MESSAGE>::GetCachedSize(
+    const ValueType& value) {
+  return WireFormatLite::LengthDelimitedSize(value.GetCachedSize());
+}
+
+#define GET_CACHED_SIZE(FieldType, DeclaredType)                         \
+  template <>                                                            \
+  template <typename ValueType>                                          \
+  inline int                                                             \
+  MapProtoTypeHandler<FieldDescriptor::TYPE_##FieldType>::GetCachedSize( \
+      const ValueType& value) {                                          \
+    return WireFormatLite::DeclaredType##Size(value);                    \
+  }
+
+GET_CACHED_SIZE(STRING, String)
+GET_CACHED_SIZE(BYTES , Bytes)
+GET_CACHED_SIZE(INT64 , Int64)
+GET_CACHED_SIZE(UINT64, UInt64)
+GET_CACHED_SIZE(INT32 , Int32)
+GET_CACHED_SIZE(UINT32, UInt32)
+GET_CACHED_SIZE(SINT64, SInt64)
+GET_CACHED_SIZE(SINT32, SInt32)
+GET_CACHED_SIZE(ENUM  , Enum)
+
+#undef GET_CACHED_SIZE
+
+#define GET_FIXED_CACHED_SIZE(FieldType, DeclaredType)                   \
+  template <>                                                            \
+  template <typename ValueType>                                          \
+  inline int                                                             \
+  MapProtoTypeHandler<FieldDescriptor::TYPE_##FieldType>::GetCachedSize( \
+      const ValueType& value) {                                          \
+    return WireFormatLite::k##DeclaredType##Size;                        \
+  }
+
+GET_FIXED_CACHED_SIZE(DOUBLE  , Double)
+GET_FIXED_CACHED_SIZE(FLOAT   , Float)
+GET_FIXED_CACHED_SIZE(FIXED64 , Fixed64)
+GET_FIXED_CACHED_SIZE(FIXED32 , Fixed32)
+GET_FIXED_CACHED_SIZE(SFIXED64, SFixed64)
+GET_FIXED_CACHED_SIZE(SFIXED32, SFixed32)
+GET_FIXED_CACHED_SIZE(BOOL    , Bool)
+
+#undef GET_FIXED_CACHED_SIZE
+
+template <>
+inline void MapProtoTypeHandler<FieldDescriptor::TYPE_MESSAGE>::Write(
+    int field, const Message& value, io::CodedOutputStream* output) {
+  WireFormatLite::WriteMessageMaybeToArray(field, value, output);
+}
+
+template <>
+inline uint8* MapProtoTypeHandler<FieldDescriptor::TYPE_MESSAGE>::WriteToArray(
+    int field, const Message& value, uint8* output) {
+  return WireFormatLite::WriteMessageToArray(field, value, output);
+}
+
+#define WRITE_METHOD(FieldType, DeclaredType)                                  \
+  template <>                                                                  \
+  inline void MapProtoTypeHandler<FieldDescriptor::TYPE_##FieldType>::Write(   \
+      int field, const CppType& value, io::CodedOutputStream* output) {        \
+    return WireFormatLite::Write##DeclaredType(field, value, output);          \
+  }                                                                            \
+  template <>                                                                  \
+  inline uint8*                                                                \
+  MapProtoTypeHandler<FieldDescriptor::TYPE_##FieldType>::WriteToArray(        \
+      int field, const CppType& value, uint8* output) {                        \
+    return WireFormatLite::Write##DeclaredType##ToArray(field, value, output); \
+  }
+
+WRITE_METHOD(STRING  , String)
+WRITE_METHOD(BYTES   , Bytes)
+WRITE_METHOD(INT64   , Int64)
+WRITE_METHOD(UINT64  , UInt64)
+WRITE_METHOD(INT32   , Int32)
+WRITE_METHOD(UINT32  , UInt32)
+WRITE_METHOD(SINT64  , SInt64)
+WRITE_METHOD(SINT32  , SInt32)
+WRITE_METHOD(ENUM    , Enum)
+WRITE_METHOD(DOUBLE  , Double)
+WRITE_METHOD(FLOAT   , Float)
+WRITE_METHOD(FIXED64 , Fixed64)
+WRITE_METHOD(FIXED32 , Fixed32)
+WRITE_METHOD(SFIXED64, SFixed64)
+WRITE_METHOD(SFIXED32, SFixed32)
+WRITE_METHOD(BOOL    , Bool)
+
+#undef WRITE_METHOD
+
+template <>
+template <typename ValueType>
+inline bool MapProtoTypeHandler<FieldDescriptor::TYPE_MESSAGE>::Read(
+    io::CodedInputStream* input, ValueType* value) {
+  return WireFormatLite::ReadMessageNoVirtual(input, value);
+}
+
+template <>
+template <typename ValueType>
+inline bool MapProtoTypeHandler<FieldDescriptor::TYPE_STRING>::Read(
+    io::CodedInputStream* input, ValueType* value) {
+  return WireFormatLite::ReadString(input, value);
+}
+
+template <>
+template <typename ValueType>
+inline bool MapProtoTypeHandler<FieldDescriptor::TYPE_BYTES>::Read(
+    io::CodedInputStream* input, ValueType* value) {
+  return WireFormatLite::ReadBytes(input, value);
+}
+
+#define READ_METHOD(FieldType)                                              \
+  template <>                                                               \
+  template <typename ValueType>                                             \
+  inline bool MapProtoTypeHandler<FieldDescriptor::TYPE_##FieldType>::Read( \
+      io::CodedInputStream* input, ValueType* value) {                      \
+    return WireFormatLite::ReadPrimitive<CppType,                           \
+                                         WireFormatLite::TYPE_##FieldType>( \
+        input, value);                                                      \
+  }
+
+READ_METHOD(INT64)
+READ_METHOD(UINT64)
+READ_METHOD(INT32)
+READ_METHOD(UINT32)
+READ_METHOD(SINT64)
+READ_METHOD(SINT32)
+READ_METHOD(ENUM)
+READ_METHOD(DOUBLE)
+READ_METHOD(FLOAT)
+READ_METHOD(FIXED64)
+READ_METHOD(FIXED32)
+READ_METHOD(SFIXED64)
+READ_METHOD(SFIXED32)
+READ_METHOD(BOOL)
+
+#undef READ_METHOD
+
+}  // namespace internal
+}  // namespace protobuf
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_TYPE_HANDLER_H__