third_party/protobuf: Update to HEAD (83d681ee2c)

third_party/protobuf/src/google/protobuf/util/internal/default_value_objectwriter.h

 // 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 104 matching lines @@
                                                  StringPiece value);
   virtual DefaultValueObjectWriter* RenderBytes(StringPiece name,
                                                 StringPiece value);
 
   virtual DefaultValueObjectWriter* RenderNull(StringPiece name);
 
   // Register the callback for scrubbing of fields. Owership of
   // field_scrub_callback pointer is also transferred to this class
   void RegisterFieldScrubCallBack(FieldScrubCallBackPtr field_scrub_callback);
 
+  // If set to true, empty lists are suppressed from output when default values
+  // are written.
+  void set_suppress_empty_list(bool value) { suppress_empty_list_ = value; }
+
  private:
   enum NodeKind {
     PRIMITIVE = 0,
     OBJECT = 1,
     LIST = 2,
     MAP = 3,
   };
 
   // "Node" represents a node in the tree that holds the input of
   // DefaultValueObjectWriter.
   class LIBPROTOBUF_EXPORT Node {
    public:
     Node(const string& name, const google::protobuf::Type* type, NodeKind kind,
-         const DataPiece& data, bool is_placeholder, const vector<string>& path,
+         const DataPiece& data, bool is_placeholder,
+         const std::vector<string>& path, bool suppress_empty_list,
          FieldScrubCallBack* field_scrub_callback);
     virtual ~Node() {
       for (int i = 0; i < children_.size(); ++i) {
         delete children_[i];
       }
     }
 
     // Adds a child to this node. Takes ownership of this child.
     void AddChild(Node* child) { children_.push_back(child); }
 
     // Finds the child given its name.
     Node* FindChild(StringPiece name);
 
     // Populates children of this Node based on its type. If there are already
     // children created, they will be merged to the result. Caller should pass
     // in TypeInfo for looking up types of the children.
     void PopulateChildren(const TypeInfo* typeinfo);
 
     // If this node is a leaf (has data), writes the current node to the
     // ObjectWriter; if not, then recursively writes the children to the
     // ObjectWriter.
     void WriteTo(ObjectWriter* ow);
 
     // Accessors
     const string& name() const { return name_; }
 
-    const vector<string>& path() const { return path_; }
+    const std::vector<string>& path() const { return path_; }
 
     const google::protobuf::Type* type() const { return type_; }
 
     void set_type(const google::protobuf::Type* type) { type_ = type; }
 
     NodeKind kind() const { return kind_; }
 
     int number_of_children() const { return children_.size(); }
 
     void set_data(const DataPiece& data) { data_ = data; }
@@ skipping 29 matching lines @@
     std::vector<Node*> children_;
     // Whether this node is a placeholder for an object or list automatically
     // generated when creating the parent node. Should be set to false after
     // the parent node's StartObject()/StartList() method is called with this
     // node's name.
     bool is_placeholder_;
 
     // Path of the field of this node
     std::vector<string> path_;
 
+    // Whether to suppress empty list output.
+    bool suppress_empty_list_;
+
     // Pointer to function for determining whether a field needs to be scrubbed
     // or not. This callback is owned by the creator of this node.
     FieldScrubCallBack* field_scrub_callback_;
 
     GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Node);
   };
 
   // Populates children of "node" if it is an "any" Node and its real type has
   // been given.
   void MaybePopulateChildrenOfAny(Node* node);
@@ skipping 16 matching lines @@
                                    const TypeInfo* typeinfo);
 
   // Type information for all the types used in the descriptor. Used to find
   // google::protobuf::Type of nested messages/enums.
   const TypeInfo* typeinfo_;
   // Whether the TypeInfo object is owned by this class.
   bool own_typeinfo_;
   // google::protobuf::Type of the root message type.
   const google::protobuf::Type& type_;
   // Holds copies of strings passed to RenderString.
-  vector<string*> string_values_;
+  std::vector<string*> string_values_;
 
   // The current Node. Owned by its parents.
   Node* current_;
   // The root Node.
   google::protobuf::scoped_ptr<Node> root_;
   // The stack to hold the path of Nodes from current_ to root_;
   std::stack<Node*> stack_;
 
+  // Whether to suppress output of empty lists.
+  bool suppress_empty_list_;
+
   // Unique Pointer to function for determining whether a field needs to be
   // scrubbed or not.
   FieldScrubCallBackPtr field_scrub_callback_;
 
   ObjectWriter* ow_;
 
   GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(DefaultValueObjectWriter);
 };
 
 }  // namespace converter
 }  // namespace util
 }  // namespace protobuf
 
 }  // namespace google
 #endif  // GOOGLE_PROTOBUF_UTIL_CONVERTER_DEFAULT_VALUE_OBJECTWRITER_H__