// 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.
// Author: kenton@google.com (Kenton Varda)
// Based on original Protocol Buffers design by
// Sanjay Ghemawat, Jeff Dean, and others.
#include <iostream>
#include <stack>
#include <unordered_map>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/message.h>
#include <google/protobuf/stubs/casts.h>
#include <google/protobuf/stubs/logging.h>
#include <google/protobuf/stubs/common.h>
#include <google/protobuf/descriptor.pb.h>
#include <google/protobuf/reflection_internal.h>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/io/zero_copy_stream_impl.h>
#include <google/protobuf/descriptor.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/map_field.h>
#include <google/protobuf/map_field_inl.h>
#include <google/protobuf/reflection_ops.h>
#include <google/protobuf/wire_format.h>
#include <google/protobuf/wire_format_lite.h>
#include <google/protobuf/stubs/strutil.h>
#include <google/protobuf/stubs/map_util.h>
#include <google/protobuf/stubs/stl_util.h>
#include <google/protobuf/stubs/hash.h>
#include <google/protobuf/port_def.inc>
namespace google {
namespace protobuf {
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
using internal::ParseClosure;
#endif
using internal::ReflectionOps;
using internal::WireFormat;
using internal::WireFormatLite;
void Message::MergeFrom(const Message& from) {
const Descriptor* descriptor = GetDescriptor();
GOOGLE_CHECK_EQ(from.GetDescriptor(), descriptor)
<< ": Tried to merge from a message with a different type. "
"to: "
<< descriptor->full_name()
<< ", "
"from: "
<< from.GetDescriptor()->full_name();
ReflectionOps::Merge(from, this);
}
void Message::CheckTypeAndMergeFrom(const MessageLite& other) {
MergeFrom(*down_cast<const Message*>(&other));
}
void Message::CopyFrom(const Message& from) {
const Descriptor* descriptor = GetDescriptor();
GOOGLE_CHECK_EQ(from.GetDescriptor(), descriptor)
<< ": Tried to copy from a message with a different type. "
"to: "
<< descriptor->full_name()
<< ", "
"from: "
<< from.GetDescriptor()->full_name();
ReflectionOps::Copy(from, this);
}
string Message::GetTypeName() const { return GetDescriptor()->full_name(); }
void Message::Clear() { ReflectionOps::Clear(this); }
bool Message::IsInitialized() const {
return ReflectionOps::IsInitialized(*this);
}
void Message::FindInitializationErrors(std::vector<string>* errors) const {
return ReflectionOps::FindInitializationErrors(*this, "", errors);
}
string Message::InitializationErrorString() const {
std::vector<string> errors;
FindInitializationErrors(&errors);
return Join(errors, ", ");
}
void Message::CheckInitialized() const {
GOOGLE_CHECK(IsInitialized()) << "Message of type \"" << GetDescriptor()->full_name()
<< "\" is missing required fields: "
<< InitializationErrorString();
}
void Message::DiscardUnknownFields() {
return ReflectionOps::DiscardUnknownFields(this);
}
#if !GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool Message::MergePartialFromCodedStream(io::CodedInputStream* input) {
return WireFormat::ParseAndMergePartial(input, this);
}
#endif
bool Message::ParseFromFileDescriptor(int file_descriptor) {
io::FileInputStream input(file_descriptor);
return ParseFromZeroCopyStream(&input) && input.GetErrno() == 0;
}
bool Message::ParsePartialFromFileDescriptor(int file_descriptor) {
io::FileInputStream input(file_descriptor);
return ParsePartialFromZeroCopyStream(&input) && input.GetErrno() == 0;
}
bool Message::ParseFromIstream(std::istream* input) {
io::IstreamInputStream zero_copy_input(input);
return ParseFromZeroCopyStream(&zero_copy_input) && input->eof();
}
bool Message::ParsePartialFromIstream(std::istream* input) {
io::IstreamInputStream zero_copy_input(input);
return ParsePartialFromZeroCopyStream(&zero_copy_input) && input->eof();
}
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
namespace internal {
class ReflectionAccessor {
public:
static void* GetOffset(void* msg, const google::protobuf::FieldDescriptor* f,
const google::protobuf::Reflection* r) {
return static_cast<char*>(msg) + CheckedCast(r)->schema_.GetFieldOffset(f);
}
static ExtensionSet* GetExtensionSet(void* msg, const google::protobuf::Reflection* r) {
return reinterpret_cast<ExtensionSet*>(
static_cast<char*>(msg) +
CheckedCast(r)->schema_.GetExtensionSetOffset());
}
static InternalMetadataWithArena* GetMetadata(void* msg,
const google::protobuf::Reflection* r) {
return reinterpret_cast<InternalMetadataWithArena*>(
static_cast<char*>(msg) + CheckedCast(r)->schema_.GetMetadataOffset());
}
static void* GetRepeatedEnum(const Reflection* reflection,
const FieldDescriptor* field, Message* msg) {
return reflection->MutableRawRepeatedField(
msg, field, FieldDescriptor::CPPTYPE_ENUM, 0, nullptr);
}
private:
static const GeneratedMessageReflection* CheckedCast(const Reflection* r) {
auto gr = dynamic_cast<const GeneratedMessageReflection*>(r);
GOOGLE_CHECK(gr != nullptr);
return gr;
}
};
} // namespace internal
void SetField(uint64 val, const FieldDescriptor* field, Message* msg,
const Reflection* reflection) {
#define STORE_TYPE(CPPTYPE_METHOD) \
do \
if (field->is_repeated()) { \
reflection->Add##CPPTYPE_METHOD(msg, field, value); \
} else { \
reflection->Set##CPPTYPE_METHOD(msg, field, value); \
} \
while (0)
switch (field->type()) {
#define HANDLE_TYPE(TYPE, CPPTYPE, CPPTYPE_METHOD) \
case FieldDescriptor::TYPE_##TYPE: { \
CPPTYPE value = val; \
STORE_TYPE(CPPTYPE_METHOD); \
break; \
}
// Varints
HANDLE_TYPE(INT32, int32, Int32)
HANDLE_TYPE(INT64, int64, Int64)
HANDLE_TYPE(UINT32, uint32, UInt32)
HANDLE_TYPE(UINT64, uint64, UInt64)
case FieldDescriptor::TYPE_SINT32: {
int32 value = WireFormatLite::ZigZagDecode32(val);
STORE_TYPE(Int32);
break;
}
case FieldDescriptor::TYPE_SINT64: {
int64 value = WireFormatLite::ZigZagDecode64(val);
STORE_TYPE(Int64);
break;
}
HANDLE_TYPE(BOOL, bool, Bool)
// Fixed
HANDLE_TYPE(FIXED32, uint32, UInt32)
HANDLE_TYPE(FIXED64, uint64, UInt64)
HANDLE_TYPE(SFIXED32, int32, Int32)
HANDLE_TYPE(SFIXED64, int64, Int64)
case FieldDescriptor::TYPE_FLOAT: {
float value;
uint32 bit_rep = val;
std::memcpy(&value, &bit_rep, sizeof(value));
STORE_TYPE(Float);
break;
}
case FieldDescriptor::TYPE_DOUBLE: {
double value;
uint64 bit_rep = val;
std::memcpy(&value, &bit_rep, sizeof(value));
STORE_TYPE(Double);
break;
}
case FieldDescriptor::TYPE_ENUM: {
int value = val;
if (field->is_repeated()) {
reflection->AddEnumValue(msg, field, value);
} else {
reflection->SetEnumValue(msg, field, value);
}
break;
}
default:
GOOGLE_LOG(FATAL) << "Error in descriptors, primitve field with field type "
<< field->type();
}
#undef STORE_TYPE
#undef HANDLE_TYPE
}
bool ReflectiveValidator(const void* arg, int val) {
auto d = static_cast<const EnumDescriptor*>(arg);
return d->FindValueByNumber(val) != nullptr;
}
ParseClosure GetPackedField(const FieldDescriptor* field, Message* msg,
const Reflection* reflection,
internal::ParseContext* ctx) {
switch (field->type()) {
#define HANDLE_PACKED_TYPE(TYPE, CPPTYPE, METHOD_NAME) \
case FieldDescriptor::TYPE_##TYPE: \
return {internal::Packed##METHOD_NAME##Parser, \
reflection->MutableRepeatedField<CPPTYPE>(msg, field)}
HANDLE_PACKED_TYPE(INT32, int32, Int32);
HANDLE_PACKED_TYPE(INT64, int64, Int64);
HANDLE_PACKED_TYPE(SINT32, int32, SInt32);
HANDLE_PACKED_TYPE(SINT64, int64, SInt64);
HANDLE_PACKED_TYPE(UINT32, uint32, UInt32);
HANDLE_PACKED_TYPE(UINT64, uint64, UInt64);
HANDLE_PACKED_TYPE(BOOL, bool, Bool);
case FieldDescriptor::TYPE_ENUM: {
auto object =
internal::ReflectionAccessor::GetRepeatedEnum(reflection, field, msg);
if (field->file()->syntax() == FileDescriptor::SYNTAX_PROTO3) {
return {internal::PackedEnumParser, object};
} else {
GOOGLE_CHECK_EQ(field->file()->options().cc_api_version(), 2);
ctx->extra_parse_data().SetEnumValidatorArg(
ReflectiveValidator, field->enum_type(),
reflection->MutableUnknownFields(msg), field->number());
return {internal::PackedValidEnumParserArg, object};
}
}
HANDLE_PACKED_TYPE(FIXED32, uint32, Fixed32);
HANDLE_PACKED_TYPE(FIXED64, uint64, Fixed64);
HANDLE_PACKED_TYPE(SFIXED32, int32, SFixed32);
HANDLE_PACKED_TYPE(SFIXED64, int64, SFixed64);
HANDLE_PACKED_TYPE(FLOAT, float, Float);
HANDLE_PACKED_TYPE(DOUBLE, double, Double);
#undef HANDLE_PACKED_TYPE
default:
GOOGLE_LOG(FATAL) << "Type is not packable " << field->type();
}
}
ParseClosure GetLenDelim(int field_number, const FieldDescriptor* field,
Message* msg, UnknownFieldSet* unknown,
const Reflection* reflection,
internal::ParseContext* ctx) {
if (field == nullptr || WireFormat::WireTypeForFieldType(field->type()) !=
WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
if (field && field->is_packable()) {
return GetPackedField(field, msg, reflection, ctx);
}
return {internal::StringParser, unknown->AddLengthDelimited(field_number)};
}
enum { kNone = 0, kVerify, kStrict } utf8_level = kNone;
internal::ParseFunc string_parsers[] = {internal::StringParser,
internal::StringParserUTF8Verify,
internal::StringParserUTF8};
internal::ParseFunc cord_parsers[] = {internal::CordParser,
internal::CordParserUTF8Verify,
internal::CordParserUTF8};
internal::ParseFunc string_piece_parsers[] = {
internal::StringPieceParser, internal::StringPieceParserUTF8Verify,
internal::StringPieceParserUTF8};
switch (field->type()) {
case FieldDescriptor::TYPE_STRING:
if (field->file()->syntax() == FileDescriptor::SYNTAX_PROTO3
) {
ctx->extra_parse_data().SetFieldName(field->full_name().c_str());
utf8_level = kStrict;
} else if (
true) {
ctx->extra_parse_data().SetFieldName(field->full_name().c_str());
utf8_level = kVerify;
}
FALLTHROUGH_INTENDED;
case FieldDescriptor::TYPE_BYTES: {
if (field->is_repeated()) {
int index = reflection->FieldSize(*msg, field);
// Add new empty value.
reflection->AddString(msg, field, "");
if (field->options().ctype() == FieldOptions::STRING ||
field->is_extension()) {
auto object = reflection->MutableRepeatedPtrField<string>(msg, field)
->Mutable(index);
return {string_parsers[utf8_level], object};
} else if (field->options().ctype() == FieldOptions::CORD) {
auto object = reflection->MutableRepeatedField<Cord>(msg, field)
->Mutable(index);
return {cord_parsers[utf8_level], object};
} else if (field->options().ctype() == FieldOptions::STRING_PIECE) {
auto object =
reflection
->MutableRepeatedPtrField<internal::StringPieceField>(msg,
field)
->Mutable(index);
return {string_piece_parsers[utf8_level], object};
}
} else {
// Clear value and make sure it's set.
reflection->SetString(msg, field, "");
if (field->options().ctype() == FieldOptions::STRING ||
field->is_extension()) {
// HACK around inability to get mutable_string in reflection
string* object = &const_cast<string&>(
reflection->GetStringReference(*msg, field, nullptr));
return {string_parsers[utf8_level], object};
} else {
void* object =
internal::ReflectionAccessor::GetOffset(msg, field, reflection);
if (field->containing_oneof()) {
object = *static_cast<Cord**>(object);
}
if (field->options().ctype() == FieldOptions::CORD) {
return {cord_parsers[utf8_level], object};
} else if (field->options().ctype() == FieldOptions::STRING_PIECE) {
return {string_piece_parsers[utf8_level], object};
}
}
}
GOOGLE_LOG(FATAL) << "No other type than string supported";
}
case FieldDescriptor::TYPE_MESSAGE: {
Message* object;
auto factory = ctx->extra_parse_data().factory;
if (field->is_repeated()) {
object = reflection->AddMessage(msg, field, factory);
} else {
object = reflection->MutableMessage(msg, field, factory);
}
return {object->_ParseFunc(), object};
}
default:
GOOGLE_LOG(FATAL) << "Wrong type for length delim " << field->type();
}
}
const char* ReflectiveParseMessageSetItem(const char* begin, const char* end,
void* object,
internal::ParseContext* ctx) {
ParseClosure child;
auto msg = static_cast<Message*>(object);
auto reflection = msg->GetReflection();
uint32 size;
auto ptr = begin;
while (ptr < end) {
uint32 tag = *ptr++;
if (tag == WireFormatLite::kMessageSetTypeIdTag) {
uint32 type_id;
ptr = Varint::Parse32(ptr, &type_id);
if (!ptr) goto error;
auto field = reflection->FindKnownExtensionByNumber(type_id);
if (ctx->extra_parse_data().payload.empty()) {
tag = *ptr++;
if (tag == WireFormatLite::kMessageSetMessageTag) {
ptr = Varint::Parse32Inline(ptr, &size);
if (!ptr) goto error;
child = GetLenDelim(type_id * 8 + 2, field, msg,
reflection->MutableUnknownFields(msg), reflection,
ctx);
if (size > end - ptr) goto len_delim_till_end;
auto newend = ptr + size;
if (!ctx->ParseExactRange(child, ptr, newend)) goto error;
ptr = newend;
} else {
goto error;
}
} else {
GOOGLE_LOG(FATAL) << "Wrong order";
}
} else if (tag == WireFormatLite::kMessageSetItemEndTag) {
if (!ctx->ValidEndGroup(tag)) goto error;
break;
} else if (tag == WireFormatLite::kMessageSetMessageTag) {
uint32 size;
ptr = Varint::Parse32Inline(ptr, &size);
if (!ptr) goto error;
child = {internal::StringParser, &ctx->extra_parse_data().payload};
if (size > end - ptr) goto len_delim_till_end;
auto newend = ptr + size;
if (!ctx->ParseExactRange(child, ptr, newend)) goto error;
ptr = newend;
} else {
GOOGLE_LOG(FATAL) << "Unknown message set item tag";
}
}
return ptr;
error:
return nullptr;
len_delim_till_end:
return ctx->StoreAndTailCall(ptr, end, {ReflectiveParseMessageSetItem, msg},
child, size);
}
ParseClosure GetGroup(int field_number, const FieldDescriptor* field,
Message* msg, UnknownFieldSet* unknown,
const Reflection* reflection) {
if (field == nullptr && field_number == 1 &&
msg->GetDescriptor()->options().message_set_wire_format()) {
return {ReflectiveParseMessageSetItem, msg};
}
if (field == nullptr || WireFormat::WireTypeForFieldType(field->type()) !=
WireFormatLite::WIRETYPE_START_GROUP) {
return {internal::UnknownGroupParse, unknown->AddGroup(field_number)};
}
Message* object;
if (field->is_repeated()) {
object = reflection->AddMessage(msg, field, nullptr);
} else {
object = reflection->MutableMessage(msg, field, nullptr);
}
return {object->_ParseFunc(), object};
}
const char* Message::_InternalParse(const char* begin, const char* end,
void* object, internal::ParseContext* ctx) {
auto msg = static_cast<Message*>(object);
const Descriptor* descriptor = msg->GetDescriptor();
const Reflection* reflection = msg->GetReflection();
auto unknown = reflection->MutableUnknownFields(msg);
GOOGLE_DCHECK(descriptor);
GOOGLE_DCHECK(reflection);
GOOGLE_DCHECK(begin <= end);
uint32 size;
internal::ParseFunc parser_till_end;
uint32 tag;
int depth;
auto ptr = begin;
while (ptr < end) {
ptr = Varint::Parse32Inline(ptr, &tag);
if (ptr == nullptr) return nullptr;
if (tag == 0) {
if (ctx->ValidEndGroup(0)) return ptr;
return nullptr;
}
if ((tag >> 3) == 0) return nullptr;
const FieldDescriptor* field = nullptr;
int field_number = WireFormatLite::GetTagFieldNumber(tag);
field = descriptor->FindFieldByNumber(field_number);
// If that failed, check if the field is an extension.
if (field == nullptr && descriptor->IsExtensionNumber(field_number)) {
auto pool = ctx->extra_parse_data().pool;
if (pool == NULL) {
field = reflection->FindKnownExtensionByNumber(field_number);
} else {
field = pool->FindExtensionByNumber(descriptor, field_number);
}
}
switch (tag & 7) {
case 0: {
uint64 val;
ptr = Varint::Parse64(ptr, &val);
if (!ptr) goto error;
if (field == nullptr ||
WireFormat::WireTypeForFieldType(field->type()) != 0) {
unknown->AddVarint(field_number, val);
break;
}
SetField(val, field, msg, reflection);
break;
}
case 1: {
uint64 val = UNALIGNED_LOAD64(ptr);
ptr = ptr + 8;
if (field == nullptr ||
WireFormat::WireTypeForFieldType(field->type()) != 1) {
unknown->AddFixed64(field_number, val);
break;
}
SetField(val, field, msg, reflection);
break;
}
case 2: {
ptr = Varint::Parse32Inline(ptr, &size);
if (!ptr) goto error;
ParseClosure child =
GetLenDelim(field_number, field, msg, unknown, reflection, ctx);
parser_till_end = child.func;
object = child.object;
if (size > end - ptr) goto len_delim_till_end;
auto newend = ptr + size;
if (!ctx->ParseExactRange(child, ptr, newend)) goto error;
ptr = newend;
break;
}
case 3: {
if (!ctx->PrepareGroup(tag, &depth)) goto error;
ParseClosure child =
GetGroup(field_number, field, msg, unknown, reflection);
parser_till_end = child.func;
object = child.object;
if (ptr < end) ptr = child(ptr, end, ctx);
if (!ptr) goto error;
if (ctx->GroupContinues(depth)) goto group_continues;
break;
}
case 4: {
if (!ctx->ValidEndGroup(tag)) goto error;
return ptr;
}
case 5: {
uint32 val = UNALIGNED_LOAD32(ptr);
ptr = ptr + 4;
if (field == nullptr ||
WireFormat::WireTypeForFieldType(field->type()) != 5) {
unknown->AddFixed32(field_number, val);
break;
}
SetField(val, field, msg, reflection);
break;
}
default:
goto error;
}
}
return ptr;
error:
return nullptr;
len_delim_till_end:
// Length delimited field crosses end
return ctx->StoreAndTailCall(ptr, end, {Message::_InternalParse, msg},
{parser_till_end, object}, size);
group_continues:
GOOGLE_DCHECK(ptr >= end);
// Group crossed end and must be continued. Either this a parse failure
// or we need to resume on the next chunk and thus save the state.
ctx->StoreGroup({Message::_InternalParse, msg}, {parser_till_end, object},
depth);
return ptr;
}
#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
void Message::SerializeWithCachedSizes(io::CodedOutputStream* output) const {
const internal::SerializationTable* table =
static_cast<const internal::SerializationTable*>(InternalGetTable());
if (table == 0) {
WireFormat::SerializeWithCachedSizes(*this, GetCachedSize(), output);
} else {
internal::TableSerialize(*this, table, output);
}
}
size_t Message::ByteSizeLong() const {
size_t size = WireFormat::ByteSize(*this);
SetCachedSize(internal::ToCachedSize(size));
return size;
}
void Message::SetCachedSize(int /* size */) const {
GOOGLE_LOG(FATAL) << "Message class \"" << GetDescriptor()->full_name()
<< "\" implements neither SetCachedSize() nor ByteSize(). "
"Must implement one or the other.";
}
size_t Message::SpaceUsedLong() const {
return GetReflection()->SpaceUsedLong(*this);
}
bool Message::SerializeToFileDescriptor(int file_descriptor) const {
io::FileOutputStream output(file_descriptor);
return SerializeToZeroCopyStream(&output) && output.Flush();
}
bool Message::SerializePartialToFileDescriptor(int file_descriptor) const {
io::FileOutputStream output(file_descriptor);
return SerializePartialToZeroCopyStream(&output) && output.Flush();
}
bool Message::SerializeToOstream(std::ostream* output) const {
{
io::OstreamOutputStream zero_copy_output(output);
if (!SerializeToZeroCopyStream(&zero_copy_output)) return false;
}
return output->good();
}
bool Message::SerializePartialToOstream(std::ostream* output) const {
io::OstreamOutputStream zero_copy_output(output);
return SerializePartialToZeroCopyStream(&zero_copy_output);
}
// =============================================================================
// Reflection and associated Template Specializations
Reflection::~Reflection() {}
void Reflection::AddAllocatedMessage(Message* /* message */,
const FieldDescriptor* /*field */,
Message* /* new_entry */) const {}
#define HANDLE_TYPE(TYPE, CPPTYPE, CTYPE) \
template <> \
const RepeatedField<TYPE>& Reflection::GetRepeatedField<TYPE>( \
const Message& message, const FieldDescriptor* field) const { \
return *static_cast<RepeatedField<TYPE>*>(MutableRawRepeatedField( \
const_cast<Message*>(&message), field, CPPTYPE, CTYPE, NULL)); \
} \
\
template <> \
RepeatedField<TYPE>* Reflection::MutableRepeatedField<TYPE>( \
Message * message, const FieldDescriptor* field) const { \
return static_cast<RepeatedField<TYPE>*>( \
MutableRawRepeatedField(message, field, CPPTYPE, CTYPE, NULL)); \
}
HANDLE_TYPE(int32, FieldDescriptor::CPPTYPE_INT32, -1);
HANDLE_TYPE(int64, FieldDescriptor::CPPTYPE_INT64, -1);
HANDLE_TYPE(uint32, FieldDescriptor::CPPTYPE_UINT32, -1);
HANDLE_TYPE(uint64, FieldDescriptor::CPPTYPE_UINT64, -1);
HANDLE_TYPE(float, FieldDescriptor::CPPTYPE_FLOAT, -1);
HANDLE_TYPE(double, FieldDescriptor::CPPTYPE_DOUBLE, -1);
HANDLE_TYPE(bool, FieldDescriptor::CPPTYPE_BOOL, -1);
#undef HANDLE_TYPE
void* Reflection::MutableRawRepeatedString(Message* message,
const FieldDescriptor* field,
bool is_string) const {
return MutableRawRepeatedField(message, field,
FieldDescriptor::CPPTYPE_STRING,
FieldOptions::STRING, NULL);
}
MapIterator Reflection::MapBegin(Message* message,
const FieldDescriptor* field) const {
GOOGLE_LOG(FATAL) << "Unimplemented Map Reflection API.";
MapIterator iter(message, field);
return iter;
}
MapIterator Reflection::MapEnd(Message* message,
const FieldDescriptor* field) const {
GOOGLE_LOG(FATAL) << "Unimplemented Map Reflection API.";
MapIterator iter(message, field);
return iter;
}
// =============================================================================
// MessageFactory
MessageFactory::~MessageFactory() {}
namespace internal {
// TODO(gerbens) make this factorized better. This should not have to hop
// to reflection. Currently uses GeneratedMessageReflection and thus is
// defined in generated_message_reflection.cc
void RegisterFileLevelMetadata(void* assign_descriptors_table);
} // namespace internal
namespace {
void RegisterFileLevelMetadata(void* assign_descriptors_table,
const string& filename) {
internal::RegisterFileLevelMetadata(assign_descriptors_table);
}
class GeneratedMessageFactory : public MessageFactory {
public:
static GeneratedMessageFactory* singleton();
struct RegistrationData {
const Metadata* file_level_metadata;
int size;
};
void RegisterFile(const char* file, void* registration_data);
void RegisterType(const Descriptor* descriptor, const Message* prototype);
// implements MessageFactory ---------------------------------------
const Message* GetPrototype(const Descriptor* type) override;
private:
// Only written at static init time, so does not require locking.
std::unordered_map<const char*, void*, hash<const char*>,
streq>
file_map_;
internal::WrappedMutex mutex_;
// Initialized lazily, so requires locking.
std::unordered_map<const Descriptor*, const Message*> type_map_;
};
GeneratedMessageFactory* GeneratedMessageFactory::singleton() {
static auto instance =
internal::OnShutdownDelete(new GeneratedMessageFactory);
return instance;
}
void GeneratedMessageFactory::RegisterFile(const char* file,
void* registration_data) {
if (!InsertIfNotPresent(&file_map_, file, registration_data)) {
GOOGLE_LOG(FATAL) << "File is already registered: " << file;
}
}
void GeneratedMessageFactory::RegisterType(const Descriptor* descriptor,
const Message* prototype) {
GOOGLE_DCHECK_EQ(descriptor->file()->pool(), DescriptorPool::generated_pool())
<< "Tried to register a non-generated type with the generated "
"type registry.";
// This should only be called as a result of calling a file registration
// function during GetPrototype(), in which case we already have locked
// the mutex.
mutex_.AssertHeld();
if (!InsertIfNotPresent(&type_map_, descriptor, prototype)) {
GOOGLE_LOG(DFATAL) << "Type is already registered: " << descriptor->full_name();
}
}
const Message* GeneratedMessageFactory::GetPrototype(const Descriptor* type) {
{
ReaderMutexLock lock(&mutex_);
const Message* result = FindPtrOrNull(type_map_, type);
if (result != NULL) return result;
}
// If the type is not in the generated pool, then we can't possibly handle
// it.
if (type->file()->pool() != DescriptorPool::generated_pool()) return NULL;
// Apparently the file hasn't been registered yet. Let's do that now.
void* registration_data =
FindPtrOrNull(file_map_, type->file()->name().c_str());
if (registration_data == NULL) {
GOOGLE_LOG(DFATAL) << "File appears to be in generated pool but wasn't "
"registered: "
<< type->file()->name();
return NULL;
}
WriterMutexLock lock(&mutex_);
// Check if another thread preempted us.
const Message* result = FindPtrOrNull(type_map_, type);
if (result == NULL) {
// Nope. OK, register everything.
RegisterFileLevelMetadata(registration_data, type->file()->name());
// Should be here now.
result = FindPtrOrNull(type_map_, type);
}
if (result == NULL) {
GOOGLE_LOG(DFATAL) << "Type appears to be in generated pool but wasn't "
<< "registered: " << type->full_name();
}
return result;
}
} // namespace
MessageFactory* MessageFactory::generated_factory() {
return GeneratedMessageFactory::singleton();
}
void MessageFactory::InternalRegisterGeneratedFile(
const char* filename, void* assign_descriptors_table) {
GeneratedMessageFactory::singleton()->RegisterFile(filename,
assign_descriptors_table);
}
void MessageFactory::InternalRegisterGeneratedMessage(
const Descriptor* descriptor, const Message* prototype) {
GeneratedMessageFactory::singleton()->RegisterType(descriptor, prototype);
}
MessageFactory* Reflection::GetMessageFactory() const {
GOOGLE_LOG(FATAL) << "Not implemented.";
return NULL;
}
void* Reflection::RepeatedFieldData(Message* message,
const FieldDescriptor* field,
FieldDescriptor::CppType cpp_type,
const Descriptor* message_type) const {
GOOGLE_LOG(FATAL) << "Not implemented.";
return NULL;
}
namespace {
template <typename T>
T* GetSingleton() {
static T singleton;
return &singleton;
}
} // namespace
const internal::RepeatedFieldAccessor* Reflection::RepeatedFieldAccessor(
const FieldDescriptor* field) const {
GOOGLE_CHECK(field->is_repeated());
switch (field->cpp_type()) {
#define HANDLE_PRIMITIVE_TYPE(TYPE, type) \
case FieldDescriptor::CPPTYPE_##TYPE: \
return GetSingleton<internal::RepeatedFieldPrimitiveAccessor<type> >();
HANDLE_PRIMITIVE_TYPE(INT32, int32)
HANDLE_PRIMITIVE_TYPE(UINT32, uint32)
HANDLE_PRIMITIVE_TYPE(INT64, int64)
HANDLE_PRIMITIVE_TYPE(UINT64, uint64)
HANDLE_PRIMITIVE_TYPE(FLOAT, float)
HANDLE_PRIMITIVE_TYPE(DOUBLE, double)
HANDLE_PRIMITIVE_TYPE(BOOL, bool)
HANDLE_PRIMITIVE_TYPE(ENUM, int32)
#undef HANDLE_PRIMITIVE_TYPE
case FieldDescriptor::CPPTYPE_STRING:
switch (field->options().ctype()) {
default:
case FieldOptions::STRING:
return GetSingleton<internal::RepeatedPtrFieldStringAccessor>();
}
break;
case FieldDescriptor::CPPTYPE_MESSAGE:
if (field->is_map()) {
return GetSingleton<internal::MapFieldAccessor>();
} else {
return GetSingleton<internal::RepeatedPtrFieldMessageAccessor>();
}
}
GOOGLE_LOG(FATAL) << "Should not reach here.";
return NULL;
}
namespace internal {
template <>
#if defined(_MSC_VER) && (_MSC_VER >= 1800)
// Note: force noinline to workaround MSVC compiler bug with /Zc:inline, issue
// #240
PROTOBUF_NOINLINE
#endif
Message*
GenericTypeHandler<Message>::NewFromPrototype(const Message* prototype,
Arena* arena) {
return prototype->New(arena);
}
template <>
#if defined(_MSC_VER) && (_MSC_VER >= 1800)
// Note: force noinline to workaround MSVC compiler bug with /Zc:inline, issue
// #240
PROTOBUF_NOINLINE
#endif
Arena*
GenericTypeHandler<Message>::GetArena(Message* value) {
return value->GetArena();
}
template <>
#if defined(_MSC_VER) && (_MSC_VER >= 1800)
// Note: force noinline to workaround MSVC compiler bug with /Zc:inline, issue
// #240
PROTOBUF_NOINLINE
#endif
void*
GenericTypeHandler<Message>::GetMaybeArenaPointer(Message* value) {
return value->GetMaybeArenaPointer();
}
} // namespace internal
} // namespace protobuf
} // namespace google