| // 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/arena.h> |
| #include <google/protobuf/generated_message_util.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) {} |
| }; |
| |
| template <typename Type, bool is_arena_constructable> |
| class MapArenaMessageCreator { |
| public: |
| // Use arena to create message if Type is arena constructable. Otherwise, |
| // create the message on heap. |
| static inline Type* CreateMessage(Arena* arena); |
| }; |
| template <typename Type> |
| class MapArenaMessageCreator<Type, true> { |
| public: |
| static inline Type* CreateMessage(Arena* arena) { |
| return Arena::CreateMessage<Type>(arena); |
| } |
| }; |
| template <typename Type> |
| class MapArenaMessageCreator<Type, false> { |
| public: |
| static inline Type* CreateMessage(Arena* arena) { |
| return new Type; |
| } |
| }; |
| |
| // 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, Arena* arena) { *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, Arena* arena) { |
| *x = NULL; |
| } |
| // Initialize value for the first time mutable accessor is called. |
| static inline void EnsureMutable(Type** value, Arena* arena) { |
| if (*value == NULL) { |
| *value = |
| MapArenaMessageCreator<Type, Arena::is_arena_constructable<Type>:: |
| type::value>::CreateMessage(arena); |
| } |
| } |
| // Return default instance if value is not initialized when calling const |
| // reference accessor. |
| static inline const Type& DefaultIfNotInitialized(const Type* value, |
| const 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, Arena* arena) { |
| *value = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString()); |
| if (arena != NULL) arena->Own(*value); |
| } |
| static inline void InitializeMaybeByDefaultEnum( |
| string** value, int default_enum_value, Arena* arena) { |
| *value = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString()); |
| if (arena != NULL) arena->Own(*value); |
| } |
| static inline void EnsureMutable(string** value, Arena* arena) { |
| if (*value == &::google::protobuf::internal::GetEmptyString()) { |
| *value = Arena::Create<string>(arena); |
| } |
| } |
| static inline const string& DefaultIfNotInitialized( |
| const string* value, |
| const 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, Arena* arena) { *value = 0; } \ |
| static inline void InitializeMaybeByDefaultEnum(CType* value, \ |
| int default_enum_value, \ |
| Arena* arena) { \ |
| *value = static_cast<CType>(default_enum_value); \ |
| } \ |
| static inline void EnsureMutable(CType* value, Arena* arena) {} \ |
| }; |
| |
| 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 wire field type |
| template <WireFormatLite::FieldType field_type> |
| class MapWireFieldTypeTraits {}; |
| |
| #define TYPE_TRAITS(FieldType, CType, WireFormatType, IsMessage, IsEnum) \ |
| template <> \ |
| class MapWireFieldTypeTraits<WireFormatLite::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 , MessageLite, 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 |
| |
| template <WireFormatLite::FieldType field_type> |
| class MapWireFieldTypeHandler { |
| public: |
| // Internal stored type in MapEntryLite for given wire field type. |
| typedef typename MapWireFieldTypeTraits<field_type>::CppType CppType; |
| // Corresponding wire type for field type. |
| static const WireFormatLite::WireType kWireType = |
| MapWireFieldTypeTraits<field_type>::kWireType; |
| // Whether wire type is for message. |
| static const bool kIsMessage = MapWireFieldTypeTraits<field_type>::kIsMessage; |
| // Whether wire type is for enum. |
| static const bool kIsEnum = MapWireFieldTypeTraits<field_type>::kIsEnum; |
| |
| // 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); |
| template <typename ValueType> |
| static inline bool Read(io::CodedInputStream* input, 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 <> |
| template <typename ValueType> |
| inline int MapWireFieldTypeHandler<WireFormatLite::TYPE_MESSAGE>::ByteSize( |
| const ValueType& value) { |
| return WireFormatLite::MessageSizeNoVirtual(value); |
| } |
| |
| #define BYTE_SIZE(FieldType, DeclaredType) \ |
| template <> \ |
| template <typename ValueType> \ |
| inline int \ |
| MapWireFieldTypeHandler<WireFormatLite::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 \ |
| MapWireFieldTypeHandler<WireFormatLite::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 MapWireFieldTypeHandler< |
| WireFormatLite::TYPE_MESSAGE>::GetCachedSize(const ValueType& value) { |
| return WireFormatLite::LengthDelimitedSize(value.GetCachedSize()); |
| } |
| |
| #define GET_CACHED_SIZE(FieldType, DeclaredType) \ |
| template <> \ |
| template <typename ValueType> \ |
| inline int \ |
| MapWireFieldTypeHandler<WireFormatLite::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 \ |
| MapWireFieldTypeHandler<WireFormatLite::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 MapWireFieldTypeHandler<WireFormatLite::TYPE_MESSAGE>::Write( |
| int field, const MessageLite& value, io::CodedOutputStream* output) { |
| WireFormatLite::WriteMessageMaybeToArray(field, value, output); |
| } |
| |
| template <> |
| inline uint8* |
| MapWireFieldTypeHandler<WireFormatLite::TYPE_MESSAGE>::WriteToArray( |
| int field, const MessageLite& value, uint8* output) { |
| return WireFormatLite::WriteMessageToArray(field, value, output); |
| } |
| |
| #define WRITE_METHOD(FieldType, DeclaredType) \ |
| template <> \ |
| inline void \ |
| MapWireFieldTypeHandler<WireFormatLite::TYPE_##FieldType>::Write( \ |
| int field, const CppType& value, io::CodedOutputStream* output) { \ |
| return WireFormatLite::Write##DeclaredType(field, value, output); \ |
| } \ |
| template <> \ |
| inline uint8* \ |
| MapWireFieldTypeHandler<WireFormatLite::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 MapWireFieldTypeHandler<WireFormatLite::TYPE_MESSAGE>::Read( |
| io::CodedInputStream* input, ValueType* value) { |
| return WireFormatLite::ReadMessageNoVirtual(input, value); |
| } |
| |
| template <> |
| template <typename ValueType> |
| inline bool MapWireFieldTypeHandler<WireFormatLite::TYPE_STRING>::Read( |
| io::CodedInputStream* input, ValueType* value) { |
| return WireFormatLite::ReadString(input, value); |
| } |
| |
| template <> |
| template <typename ValueType> |
| inline bool MapWireFieldTypeHandler<WireFormatLite::TYPE_BYTES>::Read( |
| io::CodedInputStream* input, ValueType* value) { |
| return WireFormatLite::ReadBytes(input, value); |
| } |
| |
| #define READ_METHOD(FieldType) \ |
| template <> \ |
| template <typename ValueType> \ |
| inline bool MapWireFieldTypeHandler<WireFormatLite::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__ |
