third_party/protobuf: Update to HEAD (83d681ee2c)

third_party/protobuf/src/google/protobuf/util/internal/proto_writer.cc

 // 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.
@@ skipping 46 matching lines @@
 using util::StatusOr;
 
 
 ProtoWriter::ProtoWriter(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),
+      ignore_unknown_fields_(false),
+      use_lower_camel_for_enums_(false),
       element_(NULL),
       size_insert_(),
       output_(output),
       buffer_(),
       adapter_(&buffer_),
       stream_(new CodedOutputStream(&adapter_)),
       listener_(listener),
       invalid_depth_(0),
       tracker_(new ObjectLocationTracker()) {}
 
 ProtoWriter::ProtoWriter(const TypeInfo* typeinfo,
                          const google::protobuf::Type& type,
                          strings::ByteSink* output, ErrorListener* listener)
     : master_type_(type),
       typeinfo_(typeinfo),
       own_typeinfo_(false),
       done_(false),
+      ignore_unknown_fields_(false),
+      use_lower_camel_for_enums_(false),
       element_(NULL),
       size_insert_(),
       output_(output),
       buffer_(),
       adapter_(&buffer_),
       stream_(new CodedOutputStream(&adapter_)),
       listener_(listener),
       invalid_depth_(0),
       tracker_(new ObjectLocationTracker()) {}
 
@@ skipping 161 matching lines @@
   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);
+                        CodedOutputStream* stream,
+                        bool use_lower_camel_for_enums) {
+  StatusOr<int> e = data.ToEnum(enum_type, use_lower_camel_for_enums);
   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;
 }
 
 }  // namespace
 
 ProtoWriter::ProtoElement::ProtoElement(const TypeInfo* typeinfo,
                                         const google::protobuf::Type& type,
                                         ProtoWriter* enclosing)
     : BaseElement(NULL),
       ow_(enclosing),
       parent_field_(NULL),
       typeinfo_(typeinfo),
+      proto3_(type.syntax() == google::protobuf::SYNTAX_PROTO3),
       type_(type),
-      required_fields_(GetRequiredFields(type)),
       size_index_(-1),
-      array_index_(-1) {}
+      array_index_(-1),
+      // oneof_indices_ values are 1-indexed (0 means not present).
+      oneof_indices_(type.oneofs_size() + 1) {
+  if (!proto3_) {
+    required_fields_ = GetRequiredFields(type_);
+  }
+}
 
 ProtoWriter::ProtoElement::ProtoElement(ProtoWriter::ProtoElement* parent,
                                         const google::protobuf::Field* field,
                                         const google::protobuf::Type& type,
                                         bool is_list)
     : BaseElement(parent),
       ow_(this->parent()->ow_),
       parent_field_(field),
       typeinfo_(this->parent()->typeinfo_),
+      proto3_(type.syntax() == google::protobuf::SYNTAX_PROTO3),
       type_(type),
       size_index_(
           !is_list && field->kind() == google::protobuf::Field_Kind_TYPE_MESSAGE
               ? ow_->size_insert_.size()
               : -1),
-      array_index_(is_list ? 0 : -1) {
+      array_index_(is_list ? 0 : -1),
+      // oneof_indices_ values are 1-indexed (0 means not present).
+      oneof_indices_(type_.oneofs_size() + 1) {
   if (!is_list) {
     if (ow_->IsRepeated(*field)) {
       // Update array_index_ if it is an explicit list.
       if (this->parent()->array_index_ >= 0) this->parent()->array_index_++;
-    } else {
+    } else if (!proto3_) {
+      // For required fields tracking.
       this->parent()->RegisterField(field);
     }
 
     if (field->kind() == google::protobuf::Field_Kind_TYPE_MESSAGE) {
-      required_fields_ = GetRequiredFields(type_);
+      if (!proto3_) {
+        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);
     }
   }
 }
 
 ProtoWriter::ProtoElement* ProtoWriter::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());
+  if (!proto3_) {
+    // Calls the registered error listener for any required field(s) not yet
+    // seen.
+    for (std::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();
@@ skipping 39 matching lines @@
       StrAppend(&loc, "[\"", CEscape(name), "\"]");
     }
   }
   if (ow_->IsRepeated(*parent_field_) && array_index_ > 0) {
     StrAppend(&loc, "[", array_index_ - 1, "]");
   }
   return loc.empty() ? "." : loc;
 }
 
 bool ProtoWriter::ProtoElement::IsOneofIndexTaken(int32 index) {
-  return ContainsKey(oneof_indices_, index);
+  return oneof_indices_[index];
 }
 
 void ProtoWriter::ProtoElement::TakeOneofIndex(int32 index) {
-  InsertIfNotPresent(&oneof_indices_, index);
+  oneof_indices_[index] = true;
 }
 
 void ProtoWriter::InvalidName(StringPiece unknown_name, StringPiece message) {
   listener_->InvalidName(location(), ToSnakeCase(unknown_name), message);
 }
 
 void ProtoWriter::InvalidValue(StringPiece type_name, StringPiece value) {
   listener_->InvalidValue(location(), type_name, value);
 }
 
@@ skipping 137 matching lines @@
   return this;
 }
 
 ProtoWriter* ProtoWriter::RenderPrimitiveField(
     const google::protobuf::Field& field, const google::protobuf::Type& type,
     const DataPiece& data) {
   Status status;
 
   // 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, false));
+  //
+  // For proto3, since there is no required field tracking, we only need to push
+  // ProtoElement for error cases.
+  if (!element_->proto3()) {
+    element_.reset(new ProtoElement(element_.release(), &field, type, false));
+  }
 
   if (field.kind() == google::protobuf::Field_Kind_TYPE_UNKNOWN ||
       field.kind() == google::protobuf::Field_Kind_TYPE_MESSAGE) {
+    // Push a ProtoElement for location reporting purposes.
+    if (element_->proto3()) {
+      element_.reset(new ProtoElement(element_.release(), &field, type, false));
+    }
     InvalidValue(field.type_url().empty()
                      ? google::protobuf::Field_Kind_Name(field.kind())
                      : field.type_url(),
                  data.ValueAsStringOrDefault(""));
     element_.reset(element()->pop());
     return this;
   }
 
   switch (field.kind()) {
     case google::protobuf::Field_Kind_TYPE_INT32: {
@@ skipping 52 matching lines @@
       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_->GetEnumByTypeUrl(field.type_url()),
-                         stream_.get());
+                         stream_.get(), use_lower_camel_for_enums_);
       break;
     }
     default:  // TYPE_GROUP or TYPE_MESSAGE
       status = Status(INVALID_ARGUMENT, data.ToString().ValueOrDie());
   }
 
   if (!status.ok()) {
+    // Push a ProtoElement for location reporting purposes.
+    if (element_->proto3()) {
+      element_.reset(new ProtoElement(element_.release(), &field, type, false));
+    }
     InvalidValue(google::protobuf::Field_Kind_Name(field.kind()),
                  status.error_message());
+    element_.reset(element()->pop());
+    return this;
   }
 
-  element_.reset(element()->pop());
+  if (!element_->proto3()) element_.reset(element()->pop());
+
   return this;
 }
 
 const google::protobuf::Field* ProtoWriter::BeginNamed(StringPiece name,
                                                        bool is_list) {
   if (invalid_depth_ > 0) {
     ++invalid_depth_;
     return NULL;
   }
   const google::protobuf::Field* field = Lookup(name);
@@ skipping 22 matching lines @@
     if (e->parent_field() == NULL) {
       InvalidName(unnormalized_name, "Proto fields must have a name.");
     } else if (!IsRepeated(*e->parent_field())) {
       InvalidName(unnormalized_name, "Proto fields must have a name.");
       return NULL;
     }
     return e->parent_field();
   }
   const google::protobuf::Field* field =
       typeinfo_->FindField(&e->type(), unnormalized_name);
-  if (field == NULL) InvalidName(unnormalized_name, "Cannot find field.");
+  if (field == NULL && !ignore_unknown_fields_) {
+    InvalidName(unnormalized_name, "Cannot find field.");
+  }
   return field;
 }
 
 const google::protobuf::Type* ProtoWriter::LookupType(
     const google::protobuf::Field* field) {
   return ((field->kind() == google::protobuf::Field_Kind_TYPE_MESSAGE ||
            field->kind() == google::protobuf::Field_Kind_TYPE_GROUP)
               ? typeinfo_->GetTypeByTypeUrl(field->type_url())
               : &element_->type());
 }
@@ skipping 47 matching lines @@
   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