diff options
Diffstat (limited to 'src/google/protobuf/util/internal/protostream_objectwriter.cc')
| -rw-r--r-- | src/google/protobuf/util/internal/protostream_objectwriter.cc | 1557 |
1 files changed, 1557 insertions, 0 deletions
diff --git a/src/google/protobuf/util/internal/protostream_objectwriter.cc b/src/google/protobuf/util/internal/protostream_objectwriter.cc new file mode 100644 index 00000000..f9ddbf32 --- /dev/null +++ b/src/google/protobuf/util/internal/protostream_objectwriter.cc @@ -0,0 +1,1557 @@ +// 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. + +#include <google/protobuf/util/internal/protostream_objectwriter.h> + +#include <functional> +#include <stack> + +#include <google/protobuf/stubs/time.h> +#include <google/protobuf/wire_format_lite.h> +#include <google/protobuf/util/internal/field_mask_utility.h> +#include <google/protobuf/util/internal/object_location_tracker.h> +#include <google/protobuf/util/internal/constants.h> +#include <google/protobuf/util/internal/utility.h> +#include <google/protobuf/stubs/strutil.h> +#include <google/protobuf/stubs/map_util.h> +#include <google/protobuf/stubs/statusor.h> + + +namespace google { +namespace protobuf { +namespace util { +namespace converter { + +using google::protobuf::internal::WireFormatLite; +using google::protobuf::io::CodedOutputStream; +using util::error::INVALID_ARGUMENT; +using util::Status; +using util::StatusOr; + + +ProtoStreamObjectWriter::ProtoStreamObjectWriter( + TypeResolver* type_resolver, const google::protobuf::Type& type, + strings::ByteSink* output, ErrorListener* listener) + : master_type_(type), + typeinfo_(TypeInfo::NewTypeInfo(type_resolver)), + own_typeinfo_(true), + done_(false), + element_(NULL), + size_insert_(), + output_(output), + buffer_(), + adapter_(&buffer_), + stream_(new CodedOutputStream(&adapter_)), + listener_(listener), + invalid_depth_(0), + tracker_(new ObjectLocationTracker()) {} + +ProtoStreamObjectWriter::ProtoStreamObjectWriter( + TypeInfo* typeinfo, const google::protobuf::Type& type, + strings::ByteSink* output, ErrorListener* listener) + : master_type_(type), + typeinfo_(typeinfo), + own_typeinfo_(false), + done_(false), + element_(NULL), + size_insert_(), + output_(output), + buffer_(), + adapter_(&buffer_), + stream_(new CodedOutputStream(&adapter_)), + listener_(listener), + invalid_depth_(0), + tracker_(new ObjectLocationTracker()) {} + +ProtoStreamObjectWriter::~ProtoStreamObjectWriter() { + // Cleanup explicitly in order to avoid destructor stack overflow when input + // is deeply nested. + while (element_ != NULL) { + element_.reset(element_->pop()); + } + if (own_typeinfo_) { + delete typeinfo_; + } +} + +namespace { + +// Writes an INT32 field, including tag to the stream. +inline Status WriteInt32(int field_number, const DataPiece& data, + CodedOutputStream* stream) { + StatusOr<int32> i32 = data.ToInt32(); + if (i32.ok()) { + WireFormatLite::WriteInt32(field_number, i32.ValueOrDie(), stream); + } + return i32.status(); +} + +// writes an SFIXED32 field, including tag, to the stream. +inline Status WriteSFixed32(int field_number, const DataPiece& data, + CodedOutputStream* stream) { + StatusOr<int32> i32 = data.ToInt32(); + if (i32.ok()) { + WireFormatLite::WriteSFixed32(field_number, i32.ValueOrDie(), stream); + } + return i32.status(); +} + +// Writes an SINT32 field, including tag, to the stream. +inline Status WriteSInt32(int field_number, const DataPiece& data, + CodedOutputStream* stream) { + StatusOr<int32> i32 = data.ToInt32(); + if (i32.ok()) { + WireFormatLite::WriteSInt32(field_number, i32.ValueOrDie(), stream); + } + return i32.status(); +} + +// Writes a FIXED32 field, including tag, to the stream. +inline Status WriteFixed32(int field_number, const DataPiece& data, + CodedOutputStream* stream) { + StatusOr<uint32> u32 = data.ToUint32(); + if (u32.ok()) { + WireFormatLite::WriteFixed32(field_number, u32.ValueOrDie(), stream); + } + return u32.status(); +} + +// Writes a UINT32 field, including tag, to the stream. +inline Status WriteUInt32(int field_number, const DataPiece& data, + CodedOutputStream* stream) { + StatusOr<uint32> u32 = data.ToUint32(); + if (u32.ok()) { + WireFormatLite::WriteUInt32(field_number, u32.ValueOrDie(), stream); + } + return u32.status(); +} + +// Writes an INT64 field, including tag, to the stream. +inline Status WriteInt64(int field_number, const DataPiece& data, + CodedOutputStream* stream) { + StatusOr<int64> i64 = data.ToInt64(); + if (i64.ok()) { + WireFormatLite::WriteInt64(field_number, i64.ValueOrDie(), stream); + } + return i64.status(); +} + +// Writes an SFIXED64 field, including tag, to the stream. +inline Status WriteSFixed64(int field_number, const DataPiece& data, + CodedOutputStream* stream) { + StatusOr<int64> i64 = data.ToInt64(); + if (i64.ok()) { + WireFormatLite::WriteSFixed64(field_number, i64.ValueOrDie(), stream); + } + return i64.status(); +} + +// Writes an SINT64 field, including tag, to the stream. +inline Status WriteSInt64(int field_number, const DataPiece& data, + CodedOutputStream* stream) { + StatusOr<int64> i64 = data.ToInt64(); + if (i64.ok()) { + WireFormatLite::WriteSInt64(field_number, i64.ValueOrDie(), stream); + } + return i64.status(); +} + +// Writes a FIXED64 field, including tag, to the stream. +inline Status WriteFixed64(int field_number, const DataPiece& data, + CodedOutputStream* stream) { + StatusOr<uint64> u64 = data.ToUint64(); + if (u64.ok()) { + WireFormatLite::WriteFixed64(field_number, u64.ValueOrDie(), stream); + } + return u64.status(); +} + +// Writes a UINT64 field, including tag, to the stream. +inline Status WriteUInt64(int field_number, const DataPiece& data, + CodedOutputStream* stream) { + StatusOr<uint64> u64 = data.ToUint64(); + if (u64.ok()) { + WireFormatLite::WriteUInt64(field_number, u64.ValueOrDie(), stream); + } + return u64.status(); +} + +// Writes a DOUBLE field, including tag, to the stream. +inline Status WriteDouble(int field_number, const DataPiece& data, + CodedOutputStream* stream) { + StatusOr<double> d = data.ToDouble(); + if (d.ok()) { + WireFormatLite::WriteDouble(field_number, d.ValueOrDie(), stream); + } + return d.status(); +} + +// Writes a FLOAT field, including tag, to the stream. +inline Status WriteFloat(int field_number, const DataPiece& data, + CodedOutputStream* stream) { + StatusOr<float> f = data.ToFloat(); + if (f.ok()) { + WireFormatLite::WriteFloat(field_number, f.ValueOrDie(), stream); + } + return f.status(); +} + +// Writes a BOOL field, including tag, to the stream. +inline Status WriteBool(int field_number, const DataPiece& data, + CodedOutputStream* stream) { + StatusOr<bool> b = data.ToBool(); + if (b.ok()) { + WireFormatLite::WriteBool(field_number, b.ValueOrDie(), stream); + } + return b.status(); +} + +// Writes a BYTES field, including tag, to the stream. +inline Status WriteBytes(int field_number, const DataPiece& data, + CodedOutputStream* stream) { + StatusOr<string> c = data.ToBytes(); + if (c.ok()) { + WireFormatLite::WriteBytes(field_number, c.ValueOrDie(), stream); + } + return c.status(); +} + +// Writes a STRING field, including tag, to the stream. +inline Status WriteString(int field_number, const DataPiece& data, + CodedOutputStream* stream) { + StatusOr<string> s = data.ToString(); + if (s.ok()) { + WireFormatLite::WriteString(field_number, s.ValueOrDie(), stream); + } + return s.status(); +} + +// Writes an ENUM field, including tag, to the stream. +inline Status WriteEnum(int field_number, const DataPiece& data, + const google::protobuf::Enum* enum_type, + CodedOutputStream* stream) { + StatusOr<int> e = data.ToEnum(enum_type); + if (e.ok()) { + WireFormatLite::WriteEnum(field_number, e.ValueOrDie(), stream); + } + return e.status(); +} + +// Given a google::protobuf::Type, returns the set of all required fields. +std::set<const google::protobuf::Field*> GetRequiredFields( + const google::protobuf::Type& type) { + std::set<const google::protobuf::Field*> required; + for (int i = 0; i < type.fields_size(); i++) { + const google::protobuf::Field& field = type.fields(i); + if (field.cardinality() == + google::protobuf::Field_Cardinality_CARDINALITY_REQUIRED) { + required.insert(&field); + } + } + return required; +} + +// Utility method to split a string representation of Timestamp or Duration and +// return the parts. +void SplitSecondsAndNanos(StringPiece input, StringPiece* seconds, + StringPiece* nanos) { + size_t idx = input.rfind('.'); + if (idx != string::npos) { + *seconds = input.substr(0, idx); + *nanos = input.substr(idx + 1); + } else { + *seconds = input; + *nanos = StringPiece(); + } +} + +} // namespace + +ProtoStreamObjectWriter::AnyWriter::AnyWriter(ProtoStreamObjectWriter* parent) + : parent_(parent), + ow_(), + invalid_(false), + data_(), + output_(&data_), + depth_(0), + has_injected_value_message_(false) {} + +ProtoStreamObjectWriter::AnyWriter::~AnyWriter() {} + +void ProtoStreamObjectWriter::AnyWriter::StartObject(StringPiece name) { + ++depth_; + // If an object writer is absent, that means we have not called StartAny() + // before reaching here. This is an invalid state. StartAny() gets called + // whenever we see an "@type" being rendered (see AnyWriter::RenderDataPiece). + if (ow_ == NULL) { + // Make sure we are not already in an invalid state. This avoids making + // multiple unnecessary InvalidValue calls. + if (!invalid_) { + parent_->InvalidValue("Any", + StrCat("Missing or invalid @type for any field in ", + parent_->master_type_.name())); + invalid_ = true; + } + } else if (!has_injected_value_message_ || depth_ != 1 || name != "value") { + // We don't propagate to ow_ StartObject("value") calls for nested Anys or + // Struct at depth 1 as they are nested one level deep with an injected + // "value" field. + ow_->StartObject(name); + } +} + +bool ProtoStreamObjectWriter::AnyWriter::EndObject() { + --depth_; + // As long as depth_ >= 0, we know we haven't reached the end of Any. + // Propagate these EndObject() calls to the contained ow_. If we are in a + // nested Any or Struct type, ignore the second to last EndObject call (depth_ + // == -1) + if (ow_ != NULL && (!has_injected_value_message_ || depth_ >= 0)) { + ow_->EndObject(); + } + // A negative depth_ implies that we have reached the end of Any + // object. Now we write out its contents. + if (depth_ < 0) { + WriteAny(); + return false; + } + return true; +} + +void ProtoStreamObjectWriter::AnyWriter::StartList(StringPiece name) { + ++depth_; + // We expect ow_ to be present as this call only makes sense inside an Any. + if (ow_ == NULL) { + if (!invalid_) { + parent_->InvalidValue("Any", + StrCat("Missing or invalid @type for any field in ", + parent_->master_type_.name())); + invalid_ = true; + } + } else { + ow_->StartList(name); + } +} + +void ProtoStreamObjectWriter::AnyWriter::EndList() { + --depth_; + if (depth_ < 0) { + GOOGLE_LOG(DFATAL) << "Mismatched EndList found, should not be possible"; + depth_ = 0; + } + // We don't write an error on the close, only on the open + if (ow_ != NULL) { + ow_->EndList(); + } +} + +void ProtoStreamObjectWriter::AnyWriter::RenderDataPiece( + StringPiece name, const DataPiece& value) { + // Start an Any only at depth_ 0. Other RenderDataPiece calls with "@type" + // should go to the contained ow_ as they indicate nested Anys. + if (depth_ == 0 && ow_ == NULL && name == "@type") { + StartAny(value); + } else if (ow_ == NULL) { + if (!invalid_) { + parent_->InvalidValue("Any", + StrCat("Missing or invalid @type for any field in ", + parent_->master_type_.name())); + invalid_ = true; + } + } else { + // Check to see if the data needs to be rendered with well-known-type + // renderer. + const TypeRenderer* type_renderer = + FindTypeRenderer(GetFullTypeWithUrl(ow_->master_type_.name())); + if (type_renderer) { + // TODO(rikka): Don't just ignore the util::Status object! + (*type_renderer)(ow_.get(), value); + } else { + ow_->RenderDataPiece(name, value); + } + } +} + +void ProtoStreamObjectWriter::AnyWriter::StartAny(const DataPiece& value) { + // Figure out the type url. This is a copy-paste from WriteString but we also + // need the value, so we can't just call through to that. + if (value.type() == DataPiece::TYPE_STRING) { + type_url_ = value.str().ToString(); + } else { + StatusOr<string> s = value.ToString(); + if (!s.ok()) { + parent_->InvalidValue("String", s.status().error_message()); + invalid_ = true; + return; + } + type_url_ = s.ValueOrDie(); + } + // Resolve the type url, and report an error if we failed to resolve it. + StatusOr<const google::protobuf::Type*> resolved_type = + parent_->typeinfo_->ResolveTypeUrl(type_url_); + if (!resolved_type.ok()) { + parent_->InvalidValue("Any", resolved_type.status().error_message()); + invalid_ = true; + return; + } + // At this point, type is never null. + const google::protobuf::Type* type = resolved_type.ValueOrDie(); + + // If this is the case of an Any in an Any or Struct in an Any, we need to + // expect a StartObject call with "value" while we're at depth_ 0, which we + // should ignore (not propagate to our nested object writer). We also need to + // ignore the second-to-last EndObject call, and not propagate that either. + if (type->name() == kAnyType || type->name() == kStructType) { + has_injected_value_message_ = true; + } + + // Create our object writer and initialize it with the first StartObject + // call. + ow_.reset(new ProtoStreamObjectWriter(parent_->typeinfo_, *type, &output_, + parent_->listener_)); + ow_->StartObject(""); +} + +void ProtoStreamObjectWriter::AnyWriter::WriteAny() { + if (ow_ == NULL) { + // If we had no object writer, we never got any content, so just return + // immediately, which is equivalent to writing an empty Any. + return; + } + // Render the type_url and value fields directly to the stream. + // type_url has tag 1 and value has tag 2. + WireFormatLite::WriteString(1, type_url_, parent_->stream_.get()); + if (!data_.empty()) { + WireFormatLite::WriteBytes(2, data_, parent_->stream_.get()); + } +} + +ProtoStreamObjectWriter::ProtoElement::ProtoElement( + TypeInfo* typeinfo, const google::protobuf::Type& type, + ProtoStreamObjectWriter* enclosing) + : BaseElement(NULL), + ow_(enclosing), + any_(), + field_(NULL), + typeinfo_(typeinfo), + type_(type), + required_fields_(GetRequiredFields(type)), + is_repeated_type_(false), + size_index_(-1), + array_index_(-1), + element_type_(GetElementType(type_)) { + if (element_type_ == ANY) { + any_.reset(new AnyWriter(ow_)); + } +} + +ProtoStreamObjectWriter::ProtoElement::ProtoElement( + ProtoStreamObjectWriter::ProtoElement* parent, + const google::protobuf::Field* field, const google::protobuf::Type& type, + ElementType element_type) + : BaseElement(parent), + ow_(this->parent()->ow_), + any_(), + field_(field), + typeinfo_(this->parent()->typeinfo_), + type_(type), + is_repeated_type_(element_type == ProtoElement::LIST || + element_type == ProtoElement::STRUCT_LIST || + element_type == ProtoElement::MAP || + element_type == ProtoElement::STRUCT_MAP), + size_index_(!is_repeated_type_ && + field->kind() == + google::protobuf::Field_Kind_TYPE_MESSAGE + ? ow_->size_insert_.size() + : -1), + array_index_(is_repeated_type_ ? 0 : -1), + element_type_(element_type) { + if (!is_repeated_type_) { + if (field->cardinality() == + google::protobuf::Field_Cardinality_CARDINALITY_REPEATED) { + // Update array_index_ if it is an explicit list. + if (this->parent()->array_index_ >= 0) this->parent()->array_index_++; + } else { + this->parent()->RegisterField(field); + } + if (field->kind() == google::protobuf::Field_Kind_TYPE_MESSAGE) { + required_fields_ = GetRequiredFields(type_); + int start_pos = ow_->stream_->ByteCount(); + // length of serialized message is the final buffer position minus + // starting buffer position, plus length adjustments for size fields + // of any nested messages. We start with -start_pos here, so we only + // need to add the final buffer position to it at the end. + SizeInfo info = {start_pos, -start_pos}; + ow_->size_insert_.push_back(info); + } + } + if (element_type == ANY) { + any_.reset(new AnyWriter(ow_)); + } +} + +ProtoStreamObjectWriter::ProtoElement* +ProtoStreamObjectWriter::ProtoElement::pop() { + // Calls the registered error listener for any required field(s) not yet + // seen. + for (set<const google::protobuf::Field*>::iterator it = + required_fields_.begin(); + it != required_fields_.end(); ++it) { + ow_->MissingField((*it)->name()); + } + // Computes the total number of proto bytes used by a message, also adjusts + // the size of all parent messages by the length of this size field. + // If size_index_ < 0, this is not a message, so no size field is added. + if (size_index_ >= 0) { + // Add the final buffer position to compute the total length of this + // serialized message. The stored value (before this addition) already + // contains the total length of the size fields of all nested messages + // minus the initial buffer position. + ow_->size_insert_[size_index_].size += ow_->stream_->ByteCount(); + // Calculate the length required to serialize the size field of the + // message, and propagate this additional size information upward to + // all enclosing messages. + int size = ow_->size_insert_[size_index_].size; + int length = CodedOutputStream::VarintSize32(size); + for (ProtoElement* e = parent(); e != NULL; e = e->parent()) { + // Only nested messages have size field, lists do not have size field. + if (e->size_index_ >= 0) { + ow_->size_insert_[e->size_index_].size += length; + } + } + } + return BaseElement::pop<ProtoElement>(); +} + +void ProtoStreamObjectWriter::ProtoElement::RegisterField( + const google::protobuf::Field* field) { + if (!required_fields_.empty() && + field->cardinality() == + google::protobuf::Field_Cardinality_CARDINALITY_REQUIRED) { + required_fields_.erase(field); + } +} + +string ProtoStreamObjectWriter::ProtoElement::ToString() const { + if (parent() == NULL) return ""; + string loc = parent()->ToString(); + if (field_->cardinality() != + google::protobuf::Field_Cardinality_CARDINALITY_REPEATED || + parent()->field_ != field_) { + string name = field_->name(); + int i = 0; + while (i < name.size() && (ascii_isalnum(name[i]) || name[i] == '_')) ++i; + if (i > 0 && i == name.size()) { // safe field name + if (loc.empty()) { + loc = name; + } else { + StrAppend(&loc, ".", name); + } + } else { + StrAppend(&loc, "[\"", CEscape(name), "\"]"); + } + } + if (field_->cardinality() == + google::protobuf::Field_Cardinality_CARDINALITY_REPEATED && + array_index_ > 0) { + StrAppend(&loc, "[", array_index_ - 1, "]"); + } + return loc.empty() ? "." : loc; +} + +inline void ProtoStreamObjectWriter::InvalidName(StringPiece unknown_name, + StringPiece message) { + listener_->InvalidName(location(), ToSnakeCase(unknown_name), message); +} + +inline void ProtoStreamObjectWriter::InvalidValue(StringPiece type_name, + StringPiece value) { + listener_->InvalidValue(location(), type_name, value); +} + +inline void ProtoStreamObjectWriter::MissingField(StringPiece missing_name) { + listener_->MissingField(location(), missing_name); +} + +ProtoStreamObjectWriter* ProtoStreamObjectWriter::StartObject( + StringPiece name) { + // Starting the root message. Create the root ProtoElement and return. + if (element_ == NULL) { + if (!name.empty()) { + InvalidName(name, "Root element should not be named."); + } + element_.reset(new ProtoElement(typeinfo_, master_type_, this)); + + // If master type is a special type that needs extra values to be written to + // stream, we write those values. + if (master_type_.name() == kStructType) { + StartStruct(NULL); + } else if (master_type_.name() == kStructValueType) { + // We got a StartObject call with google.protobuf.Value field. This means + // we are starting an object within google.protobuf.Value type. The only + // object within that type is a struct type. So start a struct. + const google::protobuf::Field* field = StartStructValueInStruct(NULL); + StartStruct(field); + } + return this; + } + + const google::protobuf::Field* field = NULL; + if (element_ != NULL && element_->IsAny()) { + element_->any()->StartObject(name); + return this; + } else if (element_ != NULL && + (element_->IsMap() || element_->IsStructMap())) { + field = StartMapEntry(name); + if (element_->IsStructMapEntry()) { + // If the top element is a map entry, this means we are starting another + // struct within a struct. + field = StartStructValueInStruct(field); + } + } else if (element_ != NULL && element_->IsStructList()) { + // If the top element is a list, then we are starting a list field within a + // struct. + field = Lookup(name); + field = StartStructValueInStruct(field); + } else { + field = BeginNamed(name, false); + } + if (field == NULL) { + return this; + } + + const google::protobuf::Type* type = LookupType(field); + if (type == NULL) { + ++invalid_depth_; + InvalidName(name, + StrCat("Missing descriptor for field: ", field->type_url())); + return this; + } + + if (field->type_url() == GetFullTypeWithUrl(kStructType)) { + // Start a struct object. + StartStruct(field); + } else if (field->type_url() == GetFullTypeWithUrl(kStructValueType)) { + // We got a StartObject call with google.protobuf.Value field. This means we + // are starting an object within google.protobuf.Value type. The only object + // within that type is a struct type. So start a struct. + field = StartStructValueInStruct(field); + StartStruct(field); + } else if (field->type_url() == GetFullTypeWithUrl(kAnyType)) { + // Begin an Any. We can't do the real work till we get the @type field. + WriteTag(*field); + element_.reset( + new ProtoElement(element_.release(), field, *type, ProtoElement::ANY)); + } else if (IsMap(*field)) { + // Begin a map. + // A map is triggered by a StartObject() call if the current field has a map + // type. Map values are written to proto in a manner detailed in comments + // above StartMapEntry() function. + element_.reset( + new ProtoElement(element_.release(), field, *type, ProtoElement::MAP)); + } else { + WriteTag(*field); + element_.reset(new ProtoElement(element_.release(), field, *type, + ProtoElement::MESSAGE)); + } + return this; +} + +// Proto3 maps are represented on the wire as a message with +// "key" and a "value". +// +// For example, the syntax: +// map<key_type, value_type> map_field = N; +// +// is represented as: +// message MapFieldEntry { +// option map_entry = true; // marks the map construct in the descriptor +// +// key_type key = 1; +// value_type value = 2; +// } +// repeated MapFieldEntry map_field = N; +// +// See go/proto3-maps for more information. +const google::protobuf::Field* ProtoStreamObjectWriter::StartMapEntry( + StringPiece name) { + // top of stack is already a map field + const google::protobuf::Field* field = element_->field(); + const google::protobuf::Type& type = element_->type(); + // If we come from a regular map, use MAP_ENTRY or if we come from a struct, + // use STRUCT_MAP_ENTRY. These values are used later in StartObject/StartList + // or RenderDataPiece for making appropriate decisions. + ProtoElement::ElementType element_type = element_->IsStructMap() + ? ProtoElement::STRUCT_MAP_ENTRY + : ProtoElement::MAP_ENTRY; + WriteTag(*field); + element_.reset( + new ProtoElement(element_.release(), field, type, element_type)); + RenderDataPiece("key", DataPiece(name)); + return BeginNamed("value", false); +} + +// Starts a google.protobuf.Struct. +// 'field' represents a field in a message of type google.protobuf.Struct. A +// struct contains a map with name 'fields'. This function starts this map as +// well. +// When 'field' is NULL, it means that the top level message is of struct +// type. +void ProtoStreamObjectWriter::StartStruct( + const google::protobuf::Field* field) { + const google::protobuf::Type* type = NULL; + if (field) { + type = LookupType(field); + WriteTag(*field); + element_.reset(new ProtoElement(element_.release(), field, *type, + ProtoElement::STRUCT)); + } + const google::protobuf::Field* struct_field = BeginNamed("fields", false); + + if (!struct_field) { + // It is a programmatic error if this happens. Log an error. + GOOGLE_LOG(ERROR) << "Invalid internal state. Cannot find 'fields' within " + << (field ? field->type_url() : "google.protobuf.Struct"); + return; + } + + type = LookupType(struct_field); + element_.reset(new ProtoElement(element_.release(), struct_field, *type, + ProtoElement::STRUCT_MAP)); +} + +// Starts a "struct_value" within struct.proto's google.protobuf.Value type. +// 'field' should be of the type google.protobuf.Value. +// Returns the field identifying "struct_value" within the given field. +// +// If field is NULL, then we are starting struct_value at the top-level, in +// this case skip writing any tag information for the passed field. +const google::protobuf::Field* +ProtoStreamObjectWriter::StartStructValueInStruct( + const google::protobuf::Field* field) { + if (field) { + const google::protobuf::Type* type = LookupType(field); + WriteTag(*field); + element_.reset(new ProtoElement(element_.release(), field, *type, + ProtoElement::STRUCT_VALUE)); + } + return BeginNamed("struct_value", false); +} + +// Starts a "list_value" within struct.proto's google.protobuf.Value type. +// 'field' should be of the type google.protobuf.Value. +// Returns the field identifying "list_value" within the given field. +// +// If field is NULL, then we are starting list_value at the top-level, in +// this case skip writing any tag information for the passed field. +const google::protobuf::Field* ProtoStreamObjectWriter::StartListValueInStruct( + const google::protobuf::Field* field) { + if (field) { + const google::protobuf::Type* type = LookupType(field); + WriteTag(*field); + element_.reset(new ProtoElement(element_.release(), field, *type, + ProtoElement::STRUCT_VALUE)); + } + const google::protobuf::Field* list_value = BeginNamed("list_value", false); + + if (!list_value) { + // It is a programmatic error if this happens. Log an error. + GOOGLE_LOG(ERROR) << "Invalid internal state. Cannot find 'list_value' within " + << (field ? field->type_url() : "google.protobuf.Value"); + return field; + } + + return StartRepeatedValuesInListValue(list_value); +} + +// Starts the repeated "values" field in struct.proto's +// google.protobuf.ListValue type. 'field' should be of type +// google.protobuf.ListValue. +// +// If field is NULL, then we are starting ListValue at the top-level, in +// this case skip writing any tag information for the passed field. +const google::protobuf::Field* +ProtoStreamObjectWriter::StartRepeatedValuesInListValue( + const google::protobuf::Field* field) { + if (field) { + const google::protobuf::Type* type = LookupType(field); + WriteTag(*field); + element_.reset(new ProtoElement(element_.release(), field, *type, + ProtoElement::STRUCT_LIST_VALUE)); + } + return BeginNamed("values", true); +} + +void ProtoStreamObjectWriter::SkipElements() { + if (element_ == NULL) return; + + ProtoElement::ElementType element_type = element_->element_type(); + while (element_type == ProtoElement::STRUCT || + element_type == ProtoElement::STRUCT_LIST_VALUE || + element_type == ProtoElement::STRUCT_VALUE || + element_type == ProtoElement::STRUCT_MAP_ENTRY || + element_type == ProtoElement::MAP_ENTRY) { + element_.reset(element_->pop()); + element_type = + element_ != NULL ? element_->element_type() : ProtoElement::MESSAGE; + } +} + +ProtoStreamObjectWriter* ProtoStreamObjectWriter::EndObject() { + if (invalid_depth_ > 0) { + --invalid_depth_; + return this; + } + if (element_ != NULL && element_->IsAny()) { + if (element_->any()->EndObject()) { + return this; + } + } + if (element_ != NULL) { + element_.reset(element_->pop()); + } + + // Skip sentinel elements added to keep track of new proto3 types - map, + // struct. + SkipElements(); + + // If ending the root element, + // then serialize the full message with calculated sizes. + if (element_ == NULL) { + WriteRootMessage(); + } + return this; +} + +ProtoStreamObjectWriter* ProtoStreamObjectWriter::StartList(StringPiece name) { + const google::protobuf::Field* field = NULL; + // Since we cannot have a top-level repeated item in protobuf, the only way + // element_ can be null when here is when we start a top-level list + // google.protobuf.ListValue. + if (element_ == NULL) { + if (!name.empty()) { + InvalidName(name, "Root element should not be named."); + } + element_.reset(new ProtoElement(typeinfo_, master_type_, this)); + + // If master type is a special type that needs extra values to be written to + // stream, we write those values. + if (master_type_.name() == kStructValueType) { + // We got a StartList with google.protobuf.Value master type. This means + // we have to start the "list_value" within google.protobuf.Value. + field = StartListValueInStruct(NULL); + } else if (master_type_.name() == kStructListValueType) { + // We got a StartList with google.protobuf.ListValue master type. This + // means we have to start the "values" within google.protobuf.ListValue. + field = StartRepeatedValuesInListValue(NULL); + } + + // field is NULL when master_type_ is anything other than + // google.protobuf.Value or google.protobuf.ListValue. + if (field) { + const google::protobuf::Type* type = LookupType(field); + element_.reset(new ProtoElement(element_.release(), field, *type, + ProtoElement::STRUCT_LIST)); + } + return this; + } + + if (element_->IsAny()) { + element_->any()->StartList(name); + return this; + } + // The type of element we push to stack. + ProtoElement::ElementType element_type = ProtoElement::LIST; + + // Check if we need to start a map. This can heppen when there is either a map + // or a struct type within a list. + if (element_->IsMap() || element_->IsStructMap()) { + field = StartMapEntry(name); + if (field == NULL) return this; + + if (element_->IsStructMapEntry()) { + // If the top element is a map entry, this means we are starting a list + // within a struct or a map. + // An example sequence of calls would be + // StartObject -> StartList + field = StartListValueInStruct(field); + if (field == NULL) return this; + } + + element_type = ProtoElement::STRUCT_LIST; + } else if (element_->IsStructList()) { + // If the top element is a STRUCT_LIST, this means we are starting a list + // within the current list (inside a struct). + // An example call sequence would be + // StartObject -> StartList -> StartList + // with StartObject starting a struct. + + // Lookup the last list type in element stack as we are adding an element of + // the same type. + field = Lookup(name); + if (field == NULL) return this; + + field = StartListValueInStruct(field); + if (field == NULL) return this; + + element_type = ProtoElement::STRUCT_LIST; + } else { + // Lookup field corresponding to 'name'. If it is a google.protobuf.Value + // or google.protobuf.ListValue type, then StartList is a valid call, start + // this list. + // We cannot use Lookup() here as it will produce InvalidName() error if the + // field is not found. We do not want to error here as it would cause us to + // report errors twice, once here and again later in BeginNamed() call. + // Also we ignore if the field is not found here as it is caught later. + field = typeinfo_->FindField(&element_->type(), name); + + // It is an error to try to bind to map, which behind the scenes is a list. + if (field && IsMap(*field)) { + // Push field to stack for error location tracking & reporting. + element_.reset(new ProtoElement(element_.release(), field, + *LookupType(field), + ProtoElement::MESSAGE)); + InvalidValue("Map", "Cannot bind a list to map."); + ++invalid_depth_; + element_->pop(); + return this; + } + + if (field && field->type_url() == GetFullTypeWithUrl(kStructValueType)) { + // There are 2 cases possible: + // a. g.p.Value is repeated + // b. g.p.Value is not repeated + // + // For case (a), the StartList should bind to the repeated g.p.Value. + // For case (b), the StartList should bind to g.p.ListValue within the + // g.p.Value. + // + // This means, for case (a), we treat it just like any other repeated + // message, except we would apply an appropriate element_type so future + // Start or Render calls are routed appropriately. + if (field->cardinality() != + google::protobuf::Field_Cardinality_CARDINALITY_REPEATED) { + field = StartListValueInStruct(field); + } + element_type = ProtoElement::STRUCT_LIST; + } else if (field && + field->type_url() == GetFullTypeWithUrl(kStructListValueType)) { + // We got a StartList with google.protobuf.ListValue master type. This + // means we have to start the "values" within google.protobuf.ListValue. + field = StartRepeatedValuesInListValue(field); + } else { + // If no special types are to be bound, fall back to normal processing of + // StartList. + field = BeginNamed(name, true); + } + if (field == NULL) return this; + } + + const google::protobuf::Type* type = LookupType(field); + if (type == NULL) { + ++invalid_depth_; + InvalidName(name, + StrCat("Missing descriptor for field: ", field->type_url())); + return this; + } + + element_.reset( + new ProtoElement(element_.release(), field, *type, element_type)); + return this; +} + +ProtoStreamObjectWriter* ProtoStreamObjectWriter::EndList() { + if (invalid_depth_ > 0) { + --invalid_depth_; + } else if (element_ != NULL) { + if (element_->IsAny()) { + element_->any()->EndList(); + } else { + element_.reset(element_->pop()); + // Skip sentinel elements added to keep track of new proto3 types - map, + // struct. + SkipElements(); + } + } + + // When element_ is NULL, we have reached the root message type. Write out + // the bytes. + if (element_ == NULL) { + WriteRootMessage(); + } + return this; +} + +Status ProtoStreamObjectWriter::RenderStructValue(ProtoStreamObjectWriter* ow, + const DataPiece& data) { + string struct_field_name; + switch (data.type()) { + // Our JSON parser parses numbers as either int64, uint64, or double. + case DataPiece::TYPE_INT64: + case DataPiece::TYPE_UINT64: + case DataPiece::TYPE_DOUBLE: { + struct_field_name = "number_value"; + break; + } + case DataPiece::TYPE_STRING: { + struct_field_name = "string_value"; + break; + } + case DataPiece::TYPE_BOOL: { + struct_field_name = "bool_value"; + break; + } + case DataPiece::TYPE_NULL: { + struct_field_name = "null_value"; + break; + } + default: { + return Status(INVALID_ARGUMENT, + "Invalid struct data type. Only number, string, boolean or " + "null values are supported."); + } + } + ow->RenderDataPiece(struct_field_name, data); + return Status::OK; +} + +Status ProtoStreamObjectWriter::RenderTimestamp(ProtoStreamObjectWriter* ow, + const DataPiece& data) { + if (data.type() != DataPiece::TYPE_STRING) { + return Status(INVALID_ARGUMENT, + StrCat("Invalid data type for timestamp, value is ", + data.ValueAsStringOrDefault(""))); + } + + StringPiece value(data.str()); + + int64 seconds; + int32 nanos; + if (!::google::protobuf::internal::ParseTime(value.ToString(), &seconds, + &nanos)) { + return Status(INVALID_ARGUMENT, StrCat("Invalid time format: ", value)); + } + + + ow->RenderDataPiece("seconds", DataPiece(seconds)); + ow->RenderDataPiece("nanos", DataPiece(nanos)); + return Status::OK; +} + +static inline util::Status RenderOneFieldPath(ProtoStreamObjectWriter* ow, + StringPiece path) { + ow->RenderDataPiece("paths", + DataPiece(ConvertFieldMaskPath(path, &ToSnakeCase))); + return Status::OK; +} + +Status ProtoStreamObjectWriter::RenderFieldMask(ProtoStreamObjectWriter* ow, + const DataPiece& data) { + if (data.type() != DataPiece::TYPE_STRING) { + return Status(INVALID_ARGUMENT, + StrCat("Invalid data type for field mask, value is ", + data.ValueAsStringOrDefault(""))); + } + + // TODO(tsun): figure out how to do proto descriptor based snake case + // conversions as much as possible. Because ToSnakeCase sometimes returns the + // wrong value. + google::protobuf::scoped_ptr<ResultCallback1<util::Status, StringPiece> > callback( + NewPermanentCallback(&RenderOneFieldPath, ow)); + return DecodeCompactFieldMaskPaths(data.str(), callback.get()); +} + +Status ProtoStreamObjectWriter::RenderDuration(ProtoStreamObjectWriter* ow, + const DataPiece& data) { + if (data.type() != DataPiece::TYPE_STRING) { + return Status(INVALID_ARGUMENT, + StrCat("Invalid data type for duration, value is ", + data.ValueAsStringOrDefault(""))); + } + + StringPiece value(data.str()); + + if (!value.ends_with("s")) { + return Status(INVALID_ARGUMENT, + "Illegal duration format; duration must end with 's'"); + } + value = value.substr(0, value.size() - 1); + int sign = 1; + if (value.starts_with("-")) { + sign = -1; + value = value.substr(1); + } + + StringPiece s_secs, s_nanos; + SplitSecondsAndNanos(value, &s_secs, &s_nanos); + uint64 unsigned_seconds; + if (!safe_strtou64(s_secs, &unsigned_seconds)) { + return Status(INVALID_ARGUMENT, + "Invalid duration format, failed to parse seconds"); + } + + double d_nanos = 0; + if (!safe_strtod("0." + s_nanos.ToString(), &d_nanos)) { + return Status(INVALID_ARGUMENT, + "Invalid duration format, failed to parse nanos seconds"); + } + + int32 nanos = sign * static_cast<int32>(d_nanos * kNanosPerSecond); + int64 seconds = sign * unsigned_seconds; + + if (seconds > kMaxSeconds || seconds < kMinSeconds || + nanos <= -kNanosPerSecond || nanos >= kNanosPerSecond) { + return Status(INVALID_ARGUMENT, "Duration value exceeds limits"); + } + + ow->RenderDataPiece("seconds", DataPiece(seconds)); + ow->RenderDataPiece("nanos", DataPiece(nanos)); + return Status::OK; +} + +Status ProtoStreamObjectWriter::RenderWrapperType(ProtoStreamObjectWriter* ow, + const DataPiece& data) { + ow->RenderDataPiece("value", data); + return Status::OK; +} + +ProtoStreamObjectWriter* ProtoStreamObjectWriter::RenderDataPiece( + StringPiece name, const DataPiece& data) { + Status status; + if (invalid_depth_ > 0) return this; + if (element_ != NULL && element_->IsAny()) { + element_->any()->RenderDataPiece(name, data); + return this; + } + + const google::protobuf::Field* field = NULL; + string type_url; + bool is_map_entry = false; + if (element_ == NULL) { + type_url = GetFullTypeWithUrl(master_type_.name()); + } else { + if (element_->IsMap() || element_->IsStructMap()) { + is_map_entry = true; + field = StartMapEntry(name); + } else { + field = Lookup(name); + } + if (field == NULL) { + return this; + } + type_url = field->type_url(); + } + + // Check if there are any well known type renderers available for type_url. + const TypeRenderer* type_renderer = FindTypeRenderer(type_url); + if (type_renderer != NULL) { + // Push the current element to stack so lookups in type_renderer will + // find the fields. We do an EndObject soon after, which pops this. This is + // safe because all well-known types are messages. + if (element_ == NULL) { + element_.reset(new ProtoElement(typeinfo_, master_type_, this)); + } else { + if (field) { + WriteTag(*field); + const google::protobuf::Type* type = LookupType(field); + element_.reset(new ProtoElement(element_.release(), field, *type, + ProtoElement::MESSAGE)); + } + } + status = (*type_renderer)(this, data); + if (!status.ok()) { + InvalidValue(type_url, + StrCat("Field '", name, "', ", status.error_message())); + } + EndObject(); + return this; + } else if (element_ == NULL) { // no message type found at root + element_.reset(new ProtoElement(typeinfo_, master_type_, this)); + InvalidName(name, "Root element must be a message."); + return this; + } + + if (field == NULL) { + return this; + } + const google::protobuf::Type* type = LookupType(field); + if (type == NULL) { + InvalidName(name, + StrCat("Missing descriptor for field: ", field->type_url())); + return this; + } + + // Whether we should pop at the end. Set to true if the data field is a + // message type, which can happen in case of struct values. + bool should_pop = false; + + RenderSimpleDataPiece(*field, *type, data); + + if (should_pop && element_ != NULL) { + element_.reset(element_->pop()); + } + + if (is_map_entry) { + // Ending map is the same as ending an object. + EndObject(); + } + return this; +} + +void ProtoStreamObjectWriter::RenderSimpleDataPiece( + const google::protobuf::Field& field, const google::protobuf::Type& type, + const DataPiece& data) { + // If we are rendering explicit null values and the backend proto field is not + // of the google.protobuf.NullType type, we do nothing. + if (data.type() == DataPiece::TYPE_NULL && + field.type_url() != kStructNullValueTypeUrl) { + return; + } + + // Pushing a ProtoElement and then pop it off at the end for 2 purposes: + // error location reporting and required field accounting. + element_.reset(new ProtoElement(element_.release(), &field, type, + ProtoElement::MESSAGE)); + + // Make sure that field represents a simple data type. + if (field.kind() == google::protobuf::Field_Kind_TYPE_UNKNOWN || + field.kind() == google::protobuf::Field_Kind_TYPE_MESSAGE) { + InvalidValue(field.type_url().empty() + ? google::protobuf::Field_Kind_Name(field.kind()) + : field.type_url(), + data.ValueAsStringOrDefault("")); + return; + } + + Status status; + switch (field.kind()) { + case google::protobuf::Field_Kind_TYPE_INT32: { + status = WriteInt32(field.number(), data, stream_.get()); + break; + } + case google::protobuf::Field_Kind_TYPE_SFIXED32: { + status = WriteSFixed32(field.number(), data, stream_.get()); + break; + } + case google::protobuf::Field_Kind_TYPE_SINT32: { + status = WriteSInt32(field.number(), data, stream_.get()); + break; + } + case google::protobuf::Field_Kind_TYPE_FIXED32: { + status = WriteFixed32(field.number(), data, stream_.get()); + break; + } + case google::protobuf::Field_Kind_TYPE_UINT32: { + status = WriteUInt32(field.number(), data, stream_.get()); + break; + } + case google::protobuf::Field_Kind_TYPE_INT64: { + status = WriteInt64(field.number(), data, stream_.get()); + break; + } + case google::protobuf::Field_Kind_TYPE_SFIXED64: { + status = WriteSFixed64(field.number(), data, stream_.get()); + break; + } + case google::protobuf::Field_Kind_TYPE_SINT64: { + status = WriteSInt64(field.number(), data, stream_.get()); + break; + } + case google::protobuf::Field_Kind_TYPE_FIXED64: { + status = WriteFixed64(field.number(), data, stream_.get()); + break; + } + case google::protobuf::Field_Kind_TYPE_UINT64: { + status = WriteUInt64(field.number(), data, stream_.get()); + break; + } + case google::protobuf::Field_Kind_TYPE_DOUBLE: { + status = WriteDouble(field.number(), data, stream_.get()); + break; + } + case google::protobuf::Field_Kind_TYPE_FLOAT: { + status = WriteFloat(field.number(), data, stream_.get()); + break; + } + case google::protobuf::Field_Kind_TYPE_BOOL: { + status = WriteBool(field.number(), data, stream_.get()); + break; + } + case google::protobuf::Field_Kind_TYPE_BYTES: { + status = WriteBytes(field.number(), data, stream_.get()); + break; + } + case google::protobuf::Field_Kind_TYPE_STRING: { + status = WriteString(field.number(), data, stream_.get()); + break; + } + case google::protobuf::Field_Kind_TYPE_ENUM: { + status = WriteEnum(field.number(), data, + typeinfo_->GetEnum(field.type_url()), stream_.get()); + break; + } + default: // TYPE_GROUP or TYPE_MESSAGE + status = Status(INVALID_ARGUMENT, data.ToString().ValueOrDie()); + } + if (!status.ok()) { + InvalidValue(google::protobuf::Field_Kind_Name(field.kind()), + status.error_message()); + } + element_.reset(element_->pop()); +} + +// Map of functions that are responsible for rendering well known type +// represented by the key. +hash_map<string, ProtoStreamObjectWriter::TypeRenderer>* +ProtoStreamObjectWriter::CreateRendererMap() { + google::protobuf::scoped_ptr<hash_map<string, ProtoStreamObjectWriter::TypeRenderer> > + result(new hash_map<string, ProtoStreamObjectWriter::TypeRenderer>()); + (*result)["type.googleapis.com/google.protobuf.Timestamp"] = + &ProtoStreamObjectWriter::RenderTimestamp; + (*result)["type.googleapis.com/google.protobuf.Duration"] = + &ProtoStreamObjectWriter::RenderDuration; + (*result)["type.googleapis.com/google.protobuf.FieldMask"] = + &ProtoStreamObjectWriter::RenderFieldMask; + (*result)["type.googleapis.com/google.protobuf.Double"] = + &ProtoStreamObjectWriter::RenderWrapperType; + (*result)["type.googleapis.com/google.protobuf.Float"] = + &ProtoStreamObjectWriter::RenderWrapperType; + (*result)["type.googleapis.com/google.protobuf.Int64"] = + &ProtoStreamObjectWriter::RenderWrapperType; + (*result)["type.googleapis.com/google.protobuf.UInt64"] = + &ProtoStreamObjectWriter::RenderWrapperType; + (*result)["type.googleapis.com/google.protobuf.Int32"] = + &ProtoStreamObjectWriter::RenderWrapperType; + (*result)["type.googleapis.com/google.protobuf.UInt32"] = + &ProtoStreamObjectWriter::RenderWrapperType; + (*result)["type.googleapis.com/google.protobuf.Bool"] = + &ProtoStreamObjectWriter::RenderWrapperType; + (*result)["type.googleapis.com/google.protobuf.String"] = + &ProtoStreamObjectWriter::RenderWrapperType; + (*result)["type.googleapis.com/google.protobuf.Bytes"] = + &ProtoStreamObjectWriter::RenderWrapperType; + (*result)["type.googleapis.com/google.protobuf.DoubleValue"] = + &ProtoStreamObjectWriter::RenderWrapperType; + (*result)["type.googleapis.com/google.protobuf.FloatValue"] = + &ProtoStreamObjectWriter::RenderWrapperType; + (*result)["type.googleapis.com/google.protobuf.Int64Value"] = + &ProtoStreamObjectWriter::RenderWrapperType; + (*result)["type.googleapis.com/google.protobuf.UInt64Value"] = + &ProtoStreamObjectWriter::RenderWrapperType; + (*result)["type.googleapis.com/google.protobuf.Int32Value"] = + &ProtoStreamObjectWriter::RenderWrapperType; + (*result)["type.googleapis.com/google.protobuf.UInt32Value"] = + &ProtoStreamObjectWriter::RenderWrapperType; + (*result)["type.googleapis.com/google.protobuf.BoolValue"] = + &ProtoStreamObjectWriter::RenderWrapperType; + (*result)["type.googleapis.com/google.protobuf.StringValue"] = + &ProtoStreamObjectWriter::RenderWrapperType; + (*result)["type.googleapis.com/google.protobuf.BytesValue"] = + &ProtoStreamObjectWriter::RenderWrapperType; + (*result)["type.googleapis.com/google.protobuf.Value"] = + &ProtoStreamObjectWriter::RenderStructValue; + return result.release(); +} + +ProtoStreamObjectWriter::TypeRenderer* +ProtoStreamObjectWriter::FindTypeRenderer(const string& type_url) { + static hash_map<string, TypeRenderer>* renderers = CreateRendererMap(); + return FindOrNull(*renderers, type_url); +} + +ProtoStreamObjectWriter::ProtoElement::ElementType +ProtoStreamObjectWriter::GetElementType(const google::protobuf::Type& type) { + if (type.name() == kAnyType) { + return ProtoElement::ANY; + } else if (type.name() == kStructType) { + return ProtoElement::STRUCT; + } else if (type.name() == kStructValueType) { + return ProtoElement::STRUCT_VALUE; + } else if (type.name() == kStructListValueType) { + return ProtoElement::STRUCT_LIST_VALUE; + } else { + return ProtoElement::MESSAGE; + } +} + +const google::protobuf::Field* ProtoStreamObjectWriter::BeginNamed( + StringPiece name, bool is_list) { + if (invalid_depth_ > 0) { + ++invalid_depth_; + return NULL; + } + const google::protobuf::Field* field = Lookup(name); + if (field == NULL) { + ++invalid_depth_; + // InvalidName() already called in Lookup(). + return NULL; + } + if (is_list && + field->cardinality() != + google::protobuf::Field_Cardinality_CARDINALITY_REPEATED) { + ++invalid_depth_; + InvalidName(name, "Proto field is not repeating, cannot start list."); + return NULL; + } + return field; +} + +const google::protobuf::Field* ProtoStreamObjectWriter::Lookup( + StringPiece unnormalized_name) { + ProtoElement* e = element(); + if (e == NULL) { + InvalidName(unnormalized_name, "Root element must be a message."); + return NULL; + } + if (unnormalized_name.empty()) { + // Objects in repeated field inherit the same field descriptor. + if (e->field() == NULL) { + InvalidName(unnormalized_name, "Proto fields must have a name."); + } else if (e->field()->cardinality() != + google::protobuf::Field_Cardinality_CARDINALITY_REPEATED) { + InvalidName(unnormalized_name, "Proto fields must have a name."); + return NULL; + } + return e->field(); + } + const google::protobuf::Field* field = + typeinfo_->FindField(&e->type(), unnormalized_name); + if (field == NULL) InvalidName(unnormalized_name, "Cannot find field."); + return field; +} + +const google::protobuf::Type* ProtoStreamObjectWriter::LookupType( + const google::protobuf::Field* field) { + return (field->kind() == google::protobuf::Field_Kind_TYPE_MESSAGE + ? typeinfo_->GetType(field->type_url()) + : &element_->type()); +} + +// Looks up the oneof struct field based on the data type. +StatusOr<const google::protobuf::Field*> +ProtoStreamObjectWriter::LookupStructField(DataPiece::Type type) { + const google::protobuf::Field* field = NULL; + switch (type) { + // Our JSON parser parses numbers as either int64, uint64, or double. + case DataPiece::TYPE_INT64: + case DataPiece::TYPE_UINT64: + case DataPiece::TYPE_DOUBLE: { + field = Lookup("number_value"); + break; + } + case DataPiece::TYPE_STRING: { + field = Lookup("string_value"); + break; + } + case DataPiece::TYPE_BOOL: { + field = Lookup("bool_value"); + break; + } + case DataPiece::TYPE_NULL: { + field = Lookup("null_value"); + break; + } + default: { return Status(INVALID_ARGUMENT, "Invalid struct data type"); } + } + if (field == NULL) { + return Status(INVALID_ARGUMENT, "Could not lookup struct field"); + } + return field; +} + +void ProtoStreamObjectWriter::WriteRootMessage() { + GOOGLE_DCHECK(!done_); + int curr_pos = 0; + // Calls the destructor of CodedOutputStream to remove any uninitialized + // memory from the Cord before we read it. + stream_.reset(NULL); + const void* data; + int length; + google::protobuf::io::ArrayInputStream input_stream(buffer_.data(), buffer_.size()); + while (input_stream.Next(&data, &length)) { + if (length == 0) continue; + int num_bytes = length; + // Write up to where we need to insert the size field. + // The number of bytes we may write is the smaller of: + // - the current fragment size + // - the distance to the next position where a size field needs to be + // inserted. + if (!size_insert_.empty() && + size_insert_.front().pos - curr_pos < num_bytes) { + num_bytes = size_insert_.front().pos - curr_pos; + } + output_->Append(static_cast<const char*>(data), num_bytes); + if (num_bytes < length) { + input_stream.BackUp(length - num_bytes); + } + curr_pos += num_bytes; + // Insert the size field. + // size_insert_.front(): the next <index, size> pair to be written. + // size_insert_.front().pos: position of the size field. + // size_insert_.front().size: the size (integer) to be inserted. + if (!size_insert_.empty() && curr_pos == size_insert_.front().pos) { + // Varint32 occupies at most 10 bytes. + uint8 insert_buffer[10]; + uint8* insert_buffer_pos = CodedOutputStream::WriteVarint32ToArray( + size_insert_.front().size, insert_buffer); + output_->Append(reinterpret_cast<const char*>(insert_buffer), + insert_buffer_pos - insert_buffer); + size_insert_.pop_front(); + } + } + output_->Flush(); + stream_.reset(new CodedOutputStream(&adapter_)); + done_ = true; +} + +bool ProtoStreamObjectWriter::IsMap(const google::protobuf::Field& field) { + if (field.type_url().empty() || + field.kind() != google::protobuf::Field_Kind_TYPE_MESSAGE || + field.cardinality() != + google::protobuf::Field_Cardinality_CARDINALITY_REPEATED) { + return false; + } + const google::protobuf::Type* field_type = + typeinfo_->GetType(field.type_url()); + + return GetBoolOptionOrDefault(field_type->options(), + "google.protobuf.MessageOptions.map_entry", false); +} + +void ProtoStreamObjectWriter::WriteTag(const google::protobuf::Field& field) { + WireFormatLite::WireType wire_type = WireFormatLite::WireTypeForFieldType( + static_cast<WireFormatLite::FieldType>(field.kind())); + stream_->WriteTag(WireFormatLite::MakeTag(field.number(), wire_type)); +} + +} // namespace converter +} // namespace util +} // namespace protobuf +} // namespace google |