diff options
Diffstat (limited to 'src/google/protobuf/map_type_handler.h')
-rw-r--r-- | src/google/protobuf/map_type_handler.h | 486 |
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__ |