737 lines
33 KiB
C
737 lines
33 KiB
C
![]() |
// 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_MAP_TYPE_HANDLER_H__
|
||
|
#define GOOGLE_PROTOBUF_MAP_TYPE_HANDLER_H__
|
||
|
|
||
|
#include <google/protobuf/io/coded_stream.h>
|
||
|
#include <google/protobuf/arena.h>
|
||
|
#include <google/protobuf/arenastring.h>
|
||
|
#include <google/protobuf/parse_context.h>
|
||
|
#include <google/protobuf/wire_format_lite.h>
|
||
|
|
||
|
#ifdef SWIG
|
||
|
#error "You cannot SWIG proto headers"
|
||
|
#endif
|
||
|
|
||
|
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;
|
||
|
};
|
||
|
|
||
|
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 Arena::Create<Type>(arena);
|
||
|
}
|
||
|
};
|
||
|
|
||
|
// Define constants for given wire field type
|
||
|
template <WireFormatLite::FieldType field_type, typename Type>
|
||
|
class MapWireFieldTypeTraits {};
|
||
|
|
||
|
#define TYPE_TRAITS(FieldType, CType, WireFormatType, IsMessage, IsEnum) \
|
||
|
template <typename Type> \
|
||
|
class MapWireFieldTypeTraits<WireFormatLite::TYPE_##FieldType, Type> { \
|
||
|
public: \
|
||
|
static const bool kIsMessage = IsMessage; \
|
||
|
static const bool kIsEnum = IsEnum; \
|
||
|
typedef typename MapIf<kIsMessage, Type*, CType>::type TypeOnMemory; \
|
||
|
typedef typename MapIf<kIsEnum, int, Type>::type MapEntryAccessorType; \
|
||
|
static const WireFormatLite::WireType kWireType = \
|
||
|
WireFormatLite::WIRETYPE_##WireFormatType; \
|
||
|
};
|
||
|
|
||
|
TYPE_TRAITS(MESSAGE, Type, LENGTH_DELIMITED, true, false)
|
||
|
TYPE_TRAITS(STRING, ArenaStringPtr, LENGTH_DELIMITED, false, false)
|
||
|
TYPE_TRAITS(BYTES, ArenaStringPtr, LENGTH_DELIMITED, false, false)
|
||
|
TYPE_TRAITS(INT64, int64_t, VARINT, false, false)
|
||
|
TYPE_TRAITS(UINT64, uint64_t, VARINT, false, false)
|
||
|
TYPE_TRAITS(INT32, int32_t, VARINT, false, false)
|
||
|
TYPE_TRAITS(UINT32, uint32_t, VARINT, false, false)
|
||
|
TYPE_TRAITS(SINT64, int64_t, VARINT, false, false)
|
||
|
TYPE_TRAITS(SINT32, int32_t, 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_t, FIXED64, false, false)
|
||
|
TYPE_TRAITS(FIXED32, uint32_t, FIXED32, false, false)
|
||
|
TYPE_TRAITS(SFIXED64, int64_t, FIXED64, false, false)
|
||
|
TYPE_TRAITS(SFIXED32, int32_t, FIXED32, false, false)
|
||
|
TYPE_TRAITS(BOOL, bool, VARINT, false, false)
|
||
|
|
||
|
#undef TYPE_TRAITS
|
||
|
|
||
|
template <WireFormatLite::FieldType field_type, typename Type>
|
||
|
class MapTypeHandler {};
|
||
|
|
||
|
template <typename Type>
|
||
|
class MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type> {
|
||
|
public:
|
||
|
// Enum type cannot be used for MapTypeHandler::Read. Define a type which will
|
||
|
// replace Enum with int.
|
||
|
typedef typename MapWireFieldTypeTraits<WireFormatLite::TYPE_MESSAGE,
|
||
|
Type>::MapEntryAccessorType
|
||
|
MapEntryAccessorType;
|
||
|
// Internal stored type in MapEntryLite for given wire field type.
|
||
|
typedef typename MapWireFieldTypeTraits<WireFormatLite::TYPE_MESSAGE,
|
||
|
Type>::TypeOnMemory TypeOnMemory;
|
||
|
// Corresponding wire type for field type.
|
||
|
static constexpr WireFormatLite::WireType kWireType =
|
||
|
MapWireFieldTypeTraits<WireFormatLite::TYPE_MESSAGE, Type>::kWireType;
|
||
|
// Whether wire type is for message.
|
||
|
static constexpr bool kIsMessage =
|
||
|
MapWireFieldTypeTraits<WireFormatLite::TYPE_MESSAGE, Type>::kIsMessage;
|
||
|
// Whether wire type is for enum.
|
||
|
static constexpr bool kIsEnum =
|
||
|
MapWireFieldTypeTraits<WireFormatLite::TYPE_MESSAGE, Type>::kIsEnum;
|
||
|
|
||
|
// Functions used in parsing and serialization. ===================
|
||
|
static inline size_t ByteSize(const MapEntryAccessorType& value);
|
||
|
static inline int GetCachedSize(const MapEntryAccessorType& value);
|
||
|
static inline bool Read(io::CodedInputStream* input,
|
||
|
MapEntryAccessorType* value);
|
||
|
static inline const char* Read(const char* ptr, ParseContext* ctx,
|
||
|
MapEntryAccessorType* value);
|
||
|
|
||
|
static inline uint8_t* Write(int field, const MapEntryAccessorType& value,
|
||
|
uint8_t* ptr, io::EpsCopyOutputStream* stream);
|
||
|
|
||
|
// Functions to manipulate data on memory. ========================
|
||
|
static inline const Type& GetExternalReference(const Type* value);
|
||
|
static inline void DeleteNoArena(const Type* x);
|
||
|
static inline void Merge(const Type& from, Type** to, Arena* arena);
|
||
|
static inline void Clear(Type** value, Arena* arena);
|
||
|
static constexpr TypeOnMemory Constinit();
|
||
|
|
||
|
static inline Type* EnsureMutable(Type** value, Arena* arena);
|
||
|
// SpaceUsedInMapEntry: Return bytes used by value in MapEntry, excluding
|
||
|
// those already calculate in sizeof(MapField).
|
||
|
static inline size_t SpaceUsedInMapEntryLong(const Type* value);
|
||
|
// Return default instance if value is not initialized when calling const
|
||
|
// reference accessor.
|
||
|
static inline const Type& DefaultIfNotInitialized(const Type* value);
|
||
|
// Check if all required fields have values set.
|
||
|
static inline bool IsInitialized(Type* value);
|
||
|
};
|
||
|
|
||
|
#define MAP_HANDLER(FieldType) \
|
||
|
template <typename Type> \
|
||
|
class MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type> { \
|
||
|
public: \
|
||
|
typedef typename MapWireFieldTypeTraits<WireFormatLite::TYPE_##FieldType, \
|
||
|
Type>::MapEntryAccessorType \
|
||
|
MapEntryAccessorType; \
|
||
|
typedef typename MapWireFieldTypeTraits<WireFormatLite::TYPE_##FieldType, \
|
||
|
Type>::TypeOnMemory TypeOnMemory; \
|
||
|
static const WireFormatLite::WireType kWireType = \
|
||
|
MapWireFieldTypeTraits<WireFormatLite::TYPE_##FieldType, \
|
||
|
Type>::kWireType; \
|
||
|
static const bool kIsMessage = \
|
||
|
MapWireFieldTypeTraits<WireFormatLite::TYPE_##FieldType, \
|
||
|
Type>::kIsMessage; \
|
||
|
static const bool kIsEnum = \
|
||
|
MapWireFieldTypeTraits<WireFormatLite::TYPE_##FieldType, \
|
||
|
Type>::kIsEnum; \
|
||
|
static inline int ByteSize(const MapEntryAccessorType& value); \
|
||
|
static inline int GetCachedSize(const MapEntryAccessorType& value); \
|
||
|
static inline bool Read(io::CodedInputStream* input, \
|
||
|
MapEntryAccessorType* value); \
|
||
|
static inline const char* Read(const char* begin, ParseContext* ctx, \
|
||
|
MapEntryAccessorType* value); \
|
||
|
static inline uint8_t* Write(int field, const MapEntryAccessorType& value, \
|
||
|
uint8_t* ptr, \
|
||
|
io::EpsCopyOutputStream* stream); \
|
||
|
static inline const MapEntryAccessorType& GetExternalReference( \
|
||
|
const TypeOnMemory& value); \
|
||
|
static inline void DeleteNoArena(const TypeOnMemory& x); \
|
||
|
static inline void Merge(const MapEntryAccessorType& from, \
|
||
|
TypeOnMemory* to, Arena* arena); \
|
||
|
static inline void Clear(TypeOnMemory* value, Arena* arena); \
|
||
|
static inline size_t SpaceUsedInMapEntryLong(const TypeOnMemory& value); \
|
||
|
static inline const MapEntryAccessorType& DefaultIfNotInitialized( \
|
||
|
const TypeOnMemory& value); \
|
||
|
static inline bool IsInitialized(const TypeOnMemory& value); \
|
||
|
static void DeleteNoArena(TypeOnMemory& value); \
|
||
|
static constexpr TypeOnMemory Constinit(); \
|
||
|
static inline MapEntryAccessorType* EnsureMutable(TypeOnMemory* value, \
|
||
|
Arena* arena); \
|
||
|
};
|
||
|
MAP_HANDLER(STRING)
|
||
|
MAP_HANDLER(BYTES)
|
||
|
MAP_HANDLER(INT64)
|
||
|
MAP_HANDLER(UINT64)
|
||
|
MAP_HANDLER(INT32)
|
||
|
MAP_HANDLER(UINT32)
|
||
|
MAP_HANDLER(SINT64)
|
||
|
MAP_HANDLER(SINT32)
|
||
|
MAP_HANDLER(ENUM)
|
||
|
MAP_HANDLER(DOUBLE)
|
||
|
MAP_HANDLER(FLOAT)
|
||
|
MAP_HANDLER(FIXED64)
|
||
|
MAP_HANDLER(FIXED32)
|
||
|
MAP_HANDLER(SFIXED64)
|
||
|
MAP_HANDLER(SFIXED32)
|
||
|
MAP_HANDLER(BOOL)
|
||
|
#undef MAP_HANDLER
|
||
|
|
||
|
template <typename Type>
|
||
|
inline size_t MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::ByteSize(
|
||
|
const MapEntryAccessorType& value) {
|
||
|
return WireFormatLite::MessageSizeNoVirtual(value);
|
||
|
}
|
||
|
|
||
|
#define GOOGLE_PROTOBUF_BYTE_SIZE(FieldType, DeclaredType) \
|
||
|
template <typename Type> \
|
||
|
inline int MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::ByteSize( \
|
||
|
const MapEntryAccessorType& value) { \
|
||
|
return static_cast<int>(WireFormatLite::DeclaredType##Size(value)); \
|
||
|
}
|
||
|
|
||
|
GOOGLE_PROTOBUF_BYTE_SIZE(STRING, String)
|
||
|
GOOGLE_PROTOBUF_BYTE_SIZE(BYTES, Bytes)
|
||
|
GOOGLE_PROTOBUF_BYTE_SIZE(INT64, Int64)
|
||
|
GOOGLE_PROTOBUF_BYTE_SIZE(UINT64, UInt64)
|
||
|
GOOGLE_PROTOBUF_BYTE_SIZE(INT32, Int32)
|
||
|
GOOGLE_PROTOBUF_BYTE_SIZE(UINT32, UInt32)
|
||
|
GOOGLE_PROTOBUF_BYTE_SIZE(SINT64, SInt64)
|
||
|
GOOGLE_PROTOBUF_BYTE_SIZE(SINT32, SInt32)
|
||
|
GOOGLE_PROTOBUF_BYTE_SIZE(ENUM, Enum)
|
||
|
|
||
|
#undef GOOGLE_PROTOBUF_BYTE_SIZE
|
||
|
|
||
|
#define FIXED_BYTE_SIZE(FieldType, DeclaredType) \
|
||
|
template <typename Type> \
|
||
|
inline int MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::ByteSize( \
|
||
|
const MapEntryAccessorType& /* 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 <typename Type>
|
||
|
inline int MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::GetCachedSize(
|
||
|
const MapEntryAccessorType& value) {
|
||
|
return static_cast<int>(WireFormatLite::LengthDelimitedSize(
|
||
|
static_cast<size_t>(value.GetCachedSize())));
|
||
|
}
|
||
|
|
||
|
#define GET_CACHED_SIZE(FieldType, DeclaredType) \
|
||
|
template <typename Type> \
|
||
|
inline int \
|
||
|
MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::GetCachedSize( \
|
||
|
const MapEntryAccessorType& value) { \
|
||
|
return static_cast<int>(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 <typename Type> \
|
||
|
inline int \
|
||
|
MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::GetCachedSize( \
|
||
|
const MapEntryAccessorType& /* 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 <typename Type>
|
||
|
inline uint8_t* MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::Write(
|
||
|
int field, const MapEntryAccessorType& value, uint8_t* ptr,
|
||
|
io::EpsCopyOutputStream* stream) {
|
||
|
ptr = stream->EnsureSpace(ptr);
|
||
|
return WireFormatLite::InternalWriteMessage(
|
||
|
field, value, value.GetCachedSize(), ptr, stream);
|
||
|
}
|
||
|
|
||
|
#define WRITE_METHOD(FieldType, DeclaredType) \
|
||
|
template <typename Type> \
|
||
|
inline uint8_t* \
|
||
|
MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::Write( \
|
||
|
int field, const MapEntryAccessorType& value, uint8_t* ptr, \
|
||
|
io::EpsCopyOutputStream* stream) { \
|
||
|
ptr = stream->EnsureSpace(ptr); \
|
||
|
return stream->Write##DeclaredType(field, value, ptr); \
|
||
|
}
|
||
|
|
||
|
WRITE_METHOD(STRING, String)
|
||
|
WRITE_METHOD(BYTES, Bytes)
|
||
|
|
||
|
#undef WRITE_METHOD
|
||
|
#define WRITE_METHOD(FieldType, DeclaredType) \
|
||
|
template <typename Type> \
|
||
|
inline uint8_t* \
|
||
|
MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::Write( \
|
||
|
int field, const MapEntryAccessorType& value, uint8_t* ptr, \
|
||
|
io::EpsCopyOutputStream* stream) { \
|
||
|
ptr = stream->EnsureSpace(ptr); \
|
||
|
return WireFormatLite::Write##DeclaredType##ToArray(field, value, ptr); \
|
||
|
}
|
||
|
|
||
|
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 <typename Type>
|
||
|
inline bool MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::Read(
|
||
|
io::CodedInputStream* input, MapEntryAccessorType* value) {
|
||
|
return WireFormatLite::ReadMessageNoVirtual(input, value);
|
||
|
}
|
||
|
|
||
|
template <typename Type>
|
||
|
inline bool MapTypeHandler<WireFormatLite::TYPE_STRING, Type>::Read(
|
||
|
io::CodedInputStream* input, MapEntryAccessorType* value) {
|
||
|
return WireFormatLite::ReadString(input, value);
|
||
|
}
|
||
|
|
||
|
template <typename Type>
|
||
|
inline bool MapTypeHandler<WireFormatLite::TYPE_BYTES, Type>::Read(
|
||
|
io::CodedInputStream* input, MapEntryAccessorType* value) {
|
||
|
return WireFormatLite::ReadBytes(input, value);
|
||
|
}
|
||
|
|
||
|
template <typename Type>
|
||
|
const char* MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::Read(
|
||
|
const char* ptr, ParseContext* ctx, MapEntryAccessorType* value) {
|
||
|
return ctx->ParseMessage(value, ptr);
|
||
|
}
|
||
|
|
||
|
template <typename Type>
|
||
|
const char* MapTypeHandler<WireFormatLite::TYPE_STRING, Type>::Read(
|
||
|
const char* ptr, ParseContext* ctx, MapEntryAccessorType* value) {
|
||
|
int size = ReadSize(&ptr);
|
||
|
GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
|
||
|
return ctx->ReadString(ptr, size, value);
|
||
|
}
|
||
|
|
||
|
template <typename Type>
|
||
|
const char* MapTypeHandler<WireFormatLite::TYPE_BYTES, Type>::Read(
|
||
|
const char* ptr, ParseContext* ctx, MapEntryAccessorType* value) {
|
||
|
int size = ReadSize(&ptr);
|
||
|
GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
|
||
|
return ctx->ReadString(ptr, size, value);
|
||
|
}
|
||
|
|
||
|
inline const char* ReadINT64(const char* ptr, int64_t* value) {
|
||
|
return VarintParse(ptr, reinterpret_cast<uint64_t*>(value));
|
||
|
}
|
||
|
inline const char* ReadUINT64(const char* ptr, uint64_t* value) {
|
||
|
return VarintParse(ptr, value);
|
||
|
}
|
||
|
inline const char* ReadINT32(const char* ptr, int32_t* value) {
|
||
|
return VarintParse(ptr, reinterpret_cast<uint32_t*>(value));
|
||
|
}
|
||
|
inline const char* ReadUINT32(const char* ptr, uint32_t* value) {
|
||
|
return VarintParse(ptr, value);
|
||
|
}
|
||
|
inline const char* ReadSINT64(const char* ptr, int64_t* value) {
|
||
|
*value = ReadVarintZigZag64(&ptr);
|
||
|
return ptr;
|
||
|
}
|
||
|
inline const char* ReadSINT32(const char* ptr, int32_t* value) {
|
||
|
*value = ReadVarintZigZag32(&ptr);
|
||
|
return ptr;
|
||
|
}
|
||
|
template <typename E>
|
||
|
inline const char* ReadENUM(const char* ptr, E* value) {
|
||
|
*value = static_cast<E>(ReadVarint32(&ptr));
|
||
|
return ptr;
|
||
|
}
|
||
|
inline const char* ReadBOOL(const char* ptr, bool* value) {
|
||
|
*value = static_cast<bool>(ReadVarint32(&ptr));
|
||
|
return ptr;
|
||
|
}
|
||
|
|
||
|
template <typename F>
|
||
|
inline const char* ReadUnaligned(const char* ptr, F* value) {
|
||
|
*value = UnalignedLoad<F>(ptr);
|
||
|
return ptr + sizeof(F);
|
||
|
}
|
||
|
inline const char* ReadFLOAT(const char* ptr, float* value) {
|
||
|
return ReadUnaligned(ptr, value);
|
||
|
}
|
||
|
inline const char* ReadDOUBLE(const char* ptr, double* value) {
|
||
|
return ReadUnaligned(ptr, value);
|
||
|
}
|
||
|
inline const char* ReadFIXED64(const char* ptr, uint64_t* value) {
|
||
|
return ReadUnaligned(ptr, value);
|
||
|
}
|
||
|
inline const char* ReadFIXED32(const char* ptr, uint32_t* value) {
|
||
|
return ReadUnaligned(ptr, value);
|
||
|
}
|
||
|
inline const char* ReadSFIXED64(const char* ptr, int64_t* value) {
|
||
|
return ReadUnaligned(ptr, value);
|
||
|
}
|
||
|
inline const char* ReadSFIXED32(const char* ptr, int32_t* value) {
|
||
|
return ReadUnaligned(ptr, value);
|
||
|
}
|
||
|
|
||
|
#define READ_METHOD(FieldType) \
|
||
|
template <typename Type> \
|
||
|
inline bool MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::Read( \
|
||
|
io::CodedInputStream* input, MapEntryAccessorType* value) { \
|
||
|
return WireFormatLite::ReadPrimitive<TypeOnMemory, \
|
||
|
WireFormatLite::TYPE_##FieldType>( \
|
||
|
input, value); \
|
||
|
} \
|
||
|
template <typename Type> \
|
||
|
const char* MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::Read( \
|
||
|
const char* begin, ParseContext* ctx, MapEntryAccessorType* value) { \
|
||
|
(void)ctx; \
|
||
|
return Read##FieldType(begin, 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
|
||
|
|
||
|
// Definition for message handler
|
||
|
|
||
|
template <typename Type>
|
||
|
inline const Type&
|
||
|
MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::GetExternalReference(
|
||
|
const Type* value) {
|
||
|
return *value;
|
||
|
}
|
||
|
|
||
|
template <typename Type>
|
||
|
inline size_t MapTypeHandler<WireFormatLite::TYPE_MESSAGE,
|
||
|
Type>::SpaceUsedInMapEntryLong(const Type* value) {
|
||
|
return value->SpaceUsedLong();
|
||
|
}
|
||
|
|
||
|
template <typename Type>
|
||
|
inline void MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::Clear(
|
||
|
Type** value, Arena* /* arena */) {
|
||
|
if (*value != nullptr) (*value)->Clear();
|
||
|
}
|
||
|
template <typename Type>
|
||
|
inline void MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::Merge(
|
||
|
const Type& from, Type** to, Arena* /* arena */) {
|
||
|
(*to)->MergeFrom(from);
|
||
|
}
|
||
|
|
||
|
template <typename Type>
|
||
|
void MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::DeleteNoArena(
|
||
|
const Type* ptr) {
|
||
|
delete ptr;
|
||
|
}
|
||
|
|
||
|
template <typename Type>
|
||
|
constexpr auto MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::Constinit()
|
||
|
-> TypeOnMemory {
|
||
|
return nullptr;
|
||
|
}
|
||
|
|
||
|
template <typename Type>
|
||
|
inline Type* MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::EnsureMutable(
|
||
|
Type** value, Arena* arena) {
|
||
|
if (*value == nullptr) {
|
||
|
*value = MapArenaMessageCreator<
|
||
|
Type,
|
||
|
Arena::is_arena_constructable<Type>::type::value>::CreateMessage(arena);
|
||
|
}
|
||
|
return *value;
|
||
|
}
|
||
|
|
||
|
template <typename Type>
|
||
|
inline const Type&
|
||
|
MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::DefaultIfNotInitialized(
|
||
|
const Type* value) {
|
||
|
return value != nullptr ? *value : *Type::internal_default_instance();
|
||
|
}
|
||
|
|
||
|
template <typename Type>
|
||
|
inline bool MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::IsInitialized(
|
||
|
Type* value) {
|
||
|
return value ? value->IsInitialized() : false;
|
||
|
}
|
||
|
|
||
|
// Definition for string/bytes handler
|
||
|
|
||
|
#define STRING_OR_BYTES_HANDLER_FUNCTIONS(FieldType) \
|
||
|
template <typename Type> \
|
||
|
inline const typename MapTypeHandler<WireFormatLite::TYPE_##FieldType, \
|
||
|
Type>::MapEntryAccessorType& \
|
||
|
MapTypeHandler<WireFormatLite::TYPE_##FieldType, \
|
||
|
Type>::GetExternalReference(const TypeOnMemory& value) { \
|
||
|
return value.Get(); \
|
||
|
} \
|
||
|
template <typename Type> \
|
||
|
inline size_t \
|
||
|
MapTypeHandler<WireFormatLite::TYPE_##FieldType, \
|
||
|
Type>::SpaceUsedInMapEntryLong(const TypeOnMemory& value) { \
|
||
|
return sizeof(value); \
|
||
|
} \
|
||
|
template <typename Type> \
|
||
|
inline void MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::Clear( \
|
||
|
TypeOnMemory* value, Arena* /* arena */) { \
|
||
|
value->ClearToEmpty(); \
|
||
|
} \
|
||
|
template <typename Type> \
|
||
|
inline void MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::Merge( \
|
||
|
const MapEntryAccessorType& from, TypeOnMemory* to, Arena* arena) { \
|
||
|
to->Set(from, arena); \
|
||
|
} \
|
||
|
template <typename Type> \
|
||
|
void MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::DeleteNoArena( \
|
||
|
TypeOnMemory& value) { \
|
||
|
value.Destroy(); \
|
||
|
} \
|
||
|
template <typename Type> \
|
||
|
constexpr auto \
|
||
|
MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::Constinit() \
|
||
|
->TypeOnMemory { \
|
||
|
return TypeOnMemory(&internal::fixed_address_empty_string, \
|
||
|
ConstantInitialized{}); \
|
||
|
} \
|
||
|
template <typename Type> \
|
||
|
inline typename MapTypeHandler<WireFormatLite::TYPE_##FieldType, \
|
||
|
Type>::MapEntryAccessorType* \
|
||
|
MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::EnsureMutable( \
|
||
|
TypeOnMemory* value, Arena* arena) { \
|
||
|
return value->Mutable(arena); \
|
||
|
} \
|
||
|
template <typename Type> \
|
||
|
inline const typename MapTypeHandler<WireFormatLite::TYPE_##FieldType, \
|
||
|
Type>::MapEntryAccessorType& \
|
||
|
MapTypeHandler<WireFormatLite::TYPE_##FieldType, \
|
||
|
Type>::DefaultIfNotInitialized(const TypeOnMemory& value) { \
|
||
|
return value.Get(); \
|
||
|
} \
|
||
|
template <typename Type> \
|
||
|
inline bool \
|
||
|
MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::IsInitialized( \
|
||
|
const TypeOnMemory& /* value */) { \
|
||
|
return true; \
|
||
|
}
|
||
|
STRING_OR_BYTES_HANDLER_FUNCTIONS(STRING)
|
||
|
STRING_OR_BYTES_HANDLER_FUNCTIONS(BYTES)
|
||
|
#undef STRING_OR_BYTES_HANDLER_FUNCTIONS
|
||
|
|
||
|
#define PRIMITIVE_HANDLER_FUNCTIONS(FieldType) \
|
||
|
template <typename Type> \
|
||
|
inline const typename MapTypeHandler<WireFormatLite::TYPE_##FieldType, \
|
||
|
Type>::MapEntryAccessorType& \
|
||
|
MapTypeHandler<WireFormatLite::TYPE_##FieldType, \
|
||
|
Type>::GetExternalReference(const TypeOnMemory& value) { \
|
||
|
return value; \
|
||
|
} \
|
||
|
template <typename Type> \
|
||
|
inline size_t MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>:: \
|
||
|
SpaceUsedInMapEntryLong(const TypeOnMemory& /* value */) { \
|
||
|
return 0; \
|
||
|
} \
|
||
|
template <typename Type> \
|
||
|
inline void MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::Clear( \
|
||
|
TypeOnMemory* value, Arena* /* arena */) { \
|
||
|
*value = 0; \
|
||
|
} \
|
||
|
template <typename Type> \
|
||
|
inline void MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::Merge( \
|
||
|
const MapEntryAccessorType& from, TypeOnMemory* to, \
|
||
|
Arena* /* arena */) { \
|
||
|
*to = from; \
|
||
|
} \
|
||
|
template <typename Type> \
|
||
|
inline void MapTypeHandler<WireFormatLite::TYPE_##FieldType, \
|
||
|
Type>::DeleteNoArena(TypeOnMemory& /* x */) {} \
|
||
|
template <typename Type> \
|
||
|
constexpr auto \
|
||
|
MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::Constinit() \
|
||
|
->TypeOnMemory { \
|
||
|
return 0; \
|
||
|
} \
|
||
|
template <typename Type> \
|
||
|
inline typename MapTypeHandler<WireFormatLite::TYPE_##FieldType, \
|
||
|
Type>::MapEntryAccessorType* \
|
||
|
MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::EnsureMutable( \
|
||
|
TypeOnMemory* value, Arena* /* arena */) { \
|
||
|
return value; \
|
||
|
} \
|
||
|
template <typename Type> \
|
||
|
inline const typename MapTypeHandler<WireFormatLite::TYPE_##FieldType, \
|
||
|
Type>::MapEntryAccessorType& \
|
||
|
MapTypeHandler<WireFormatLite::TYPE_##FieldType, \
|
||
|
Type>::DefaultIfNotInitialized(const TypeOnMemory& value) { \
|
||
|
return value; \
|
||
|
} \
|
||
|
template <typename Type> \
|
||
|
inline bool \
|
||
|
MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::IsInitialized( \
|
||
|
const TypeOnMemory& /* value */) { \
|
||
|
return true; \
|
||
|
}
|
||
|
PRIMITIVE_HANDLER_FUNCTIONS(INT64)
|
||
|
PRIMITIVE_HANDLER_FUNCTIONS(UINT64)
|
||
|
PRIMITIVE_HANDLER_FUNCTIONS(INT32)
|
||
|
PRIMITIVE_HANDLER_FUNCTIONS(UINT32)
|
||
|
PRIMITIVE_HANDLER_FUNCTIONS(SINT64)
|
||
|
PRIMITIVE_HANDLER_FUNCTIONS(SINT32)
|
||
|
PRIMITIVE_HANDLER_FUNCTIONS(ENUM)
|
||
|
PRIMITIVE_HANDLER_FUNCTIONS(DOUBLE)
|
||
|
PRIMITIVE_HANDLER_FUNCTIONS(FLOAT)
|
||
|
PRIMITIVE_HANDLER_FUNCTIONS(FIXED64)
|
||
|
PRIMITIVE_HANDLER_FUNCTIONS(FIXED32)
|
||
|
PRIMITIVE_HANDLER_FUNCTIONS(SFIXED64)
|
||
|
PRIMITIVE_HANDLER_FUNCTIONS(SFIXED32)
|
||
|
PRIMITIVE_HANDLER_FUNCTIONS(BOOL)
|
||
|
#undef PRIMITIVE_HANDLER_FUNCTIONS
|
||
|
|
||
|
// Functions for operating on a map entry using type handlers.
|
||
|
//
|
||
|
// Does not contain any representation (this class is not intended to be
|
||
|
// instantiated).
|
||
|
template <typename Key, typename Value, WireFormatLite::FieldType kKeyFieldType,
|
||
|
WireFormatLite::FieldType kValueFieldType>
|
||
|
struct MapEntryFuncs {
|
||
|
typedef MapTypeHandler<kKeyFieldType, Key> KeyTypeHandler;
|
||
|
typedef MapTypeHandler<kValueFieldType, Value> ValueTypeHandler;
|
||
|
enum : int {
|
||
|
kKeyFieldNumber = 1,
|
||
|
kValueFieldNumber = 2
|
||
|
};
|
||
|
|
||
|
static uint8_t* InternalSerialize(int field_number, const Key& key,
|
||
|
const Value& value, uint8_t* ptr,
|
||
|
io::EpsCopyOutputStream* stream) {
|
||
|
ptr = stream->EnsureSpace(ptr);
|
||
|
ptr = WireFormatLite::WriteTagToArray(
|
||
|
field_number, WireFormatLite::WIRETYPE_LENGTH_DELIMITED, ptr);
|
||
|
ptr = io::CodedOutputStream::WriteVarint32ToArray(GetCachedSize(key, value),
|
||
|
ptr);
|
||
|
|
||
|
ptr = KeyTypeHandler::Write(kKeyFieldNumber, key, ptr, stream);
|
||
|
return ValueTypeHandler::Write(kValueFieldNumber, value, ptr, stream);
|
||
|
}
|
||
|
|
||
|
static size_t ByteSizeLong(const Key& key, const Value& value) {
|
||
|
// Tags for key and value will both be one byte (field numbers 1 and 2).
|
||
|
size_t inner_length =
|
||
|
2 + KeyTypeHandler::ByteSize(key) + ValueTypeHandler::ByteSize(value);
|
||
|
return inner_length + io::CodedOutputStream::VarintSize32(
|
||
|
static_cast<uint32_t>(inner_length));
|
||
|
}
|
||
|
|
||
|
static int GetCachedSize(const Key& key, const Value& value) {
|
||
|
// Tags for key and value will both be one byte (field numbers 1 and 2).
|
||
|
return 2 + KeyTypeHandler::GetCachedSize(key) +
|
||
|
ValueTypeHandler::GetCachedSize(value);
|
||
|
}
|
||
|
};
|
||
|
|
||
|
} // namespace internal
|
||
|
} // namespace protobuf
|
||
|
} // namespace google
|
||
|
|
||
|
#endif // GOOGLE_PROTOBUF_MAP_TYPE_HANDLER_H__
|