third_party/protobuf: Update to HEAD (83d681ee2c)

third_party/protobuf/src/google/protobuf/util/internal/protostream_objectsource.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 99 matching lines @@
     use_lower_camel_for_enums_ = value;
   }
 
   // Sets the max recursion depth of proto message to be deserialized. Proto
   // messages over this depth will fail to be deserialized.
   // Default value is 64.
   void set_max_recursion_depth(int max_depth) {
     max_recursion_depth_ = max_depth;
   }
 
+
  protected:
   // Writes a proto2 Message to the ObjectWriter. When the given end_tag is
   // found this method will complete, allowing it to be used for parsing both
   // nested messages (end with 0) and nested groups (end with group end tag).
   // The include_start_and_end parameter allows this method to be called when
   // already inside of an object, and skip calling StartObject and EndObject.
   virtual util::Status WriteMessage(const google::protobuf::Type& descriptor,
                                       StringPiece name, const uint32 end_tag,
                                       bool include_start_and_end,
                                       ObjectWriter* ow) const;
 
+  // Renders a repeating field (packed or unpacked).  Returns the next tag after
+  // reading all sequential repeating elements. The caller should use this tag
+  // before reading more tags from the stream.
+  virtual util::StatusOr<uint32> RenderList(
+      const google::protobuf::Field* field, StringPiece name, uint32 list_tag,
+      ObjectWriter* ow) const;
+
+  // Looks up a field and verify its consistency with wire type in tag.
+  const google::protobuf::Field* FindAndVerifyField(
+      const google::protobuf::Type& type, uint32 tag) const;
+
+  // Renders a field value to the ObjectWriter.
+  util::Status RenderField(const google::protobuf::Field* field,
+                             StringPiece field_name, ObjectWriter* ow) const;
+
+  // Reads field value according to Field spec in 'field' and returns the read
+  // value as string. This only works for primitive datatypes (no message
+  // types).
+  const string ReadFieldValueAsString(
+      const google::protobuf::Field& field) const;
+
+
  private:
   ProtoStreamObjectSource(google::protobuf::io::CodedInputStream* stream,
                           const TypeInfo* typeinfo,
                           const google::protobuf::Type& type);
   // Function that renders a well known type with a modified behavior.
   typedef util::Status (*TypeRenderer)(const ProtoStreamObjectSource*,
                                          const google::protobuf::Type&,
                                          StringPiece, ObjectWriter*);
 
-  // Looks up a field and verify its consistency with wire type in tag.
-  const google::protobuf::Field* FindAndVerifyField(
-      const google::protobuf::Type& type, uint32 tag) const;
-
   // TODO(skarvaje): Mark these methods as non-const as they modify internal
   // state (stream_).
   //
-  // Renders a repeating field (packed or unpacked).
-  // Returns the next tag after reading all sequential repeating elements. The
-  // caller should use this tag before reading more tags from the stream.
-  util::StatusOr<uint32> RenderList(const google::protobuf::Field* field,
-                                      StringPiece name, uint32 list_tag,
-                                      ObjectWriter* ow) const;
   // Renders a NWP map.
   // Returns the next tag after reading all map entries. The caller should use
   // this tag before reading more tags from the stream.
   util::StatusOr<uint32> RenderMap(const google::protobuf::Field* field,
                                      StringPiece name, uint32 list_tag,
                                      ObjectWriter* ow) const;
 
   // Renders a packed repeating field. A packed field is stored as:
   // {tag length item1 item2 item3} instead of the less efficient
   // {tag item1 tag item2 tag item3}.
@@ skipping 63 matching lines @@
   // Render the "FieldMask" type.
   static util::Status RenderFieldMask(const ProtoStreamObjectSource* os,
                                         const google::protobuf::Type& type,
                                         StringPiece name, ObjectWriter* ow);
 
   static hash_map<string, TypeRenderer>* renderers_;
   static void InitRendererMap();
   static void DeleteRendererMap();
   static TypeRenderer* FindTypeRenderer(const string& type_url);
 
-  // Renders a field value to the ObjectWriter.
-  util::Status RenderField(const google::protobuf::Field* field,
-                             StringPiece field_name, ObjectWriter* ow) const;
-
   // Same as above but renders all non-message field types. Callers don't call
   // this function directly. They just use RenderField.
   util::Status RenderNonMessageField(const google::protobuf::Field* field,
                                        StringPiece field_name,
                                        ObjectWriter* ow) const;
 
 
-  // Reads field value according to Field spec in 'field' and returns the read
-  // value as string. This only works for primitive datatypes (no message
-  // types).
-  const string ReadFieldValueAsString(
-      const google::protobuf::Field& field) const;
-
   // Utility function to detect proto maps. The 'field' MUST be repeated.
   bool IsMap(const google::protobuf::Field& field) const;
 
   // Utility to read int64 and int32 values from a message type in stream_.
   // Used for reading google.protobuf.Timestamp and Duration messages.
   std::pair<int64, int32> ReadSecondsAndNanos(
       const google::protobuf::Type& type) const;
 
   // Helper function to check recursion depth and increment it. It will return
   // Status::OK if the current depth is allowed. Otherwise an error is returned.
   // type_name and field_name are used for error reporting.
   util::Status IncrementRecursionDepth(StringPiece type_name,
                                          StringPiece field_name) const;
 
   // Input stream to read from. Ownership rests with the caller.
   google::protobuf::io::CodedInputStream* stream_;
 
   // Type information for all the types used in the descriptor. Used to find
   // google::protobuf::Type of nested messages/enums.
   const TypeInfo* typeinfo_;
+
   // Whether this class owns the typeinfo_ object. If true the typeinfo_ object
   // should be deleted in the destructor.
   bool own_typeinfo_;
 
   // google::protobuf::Type of the message source.
   const google::protobuf::Type& type_;
 
 
   // Whether to render enums using lowerCamelCase. Defaults to false.
   bool use_lower_camel_for_enums_;
 
   // Tracks current recursion depth.
   mutable int recursion_depth_;
 
   // Maximum allowed recursion depth.
   int max_recursion_depth_;
 
+  // Whether to render unknown fields.
+  bool render_unknown_fields_;
+
+  // Whether to add trailing zeros for timestamp and duration.
+  bool add_trailing_zeros_for_timestamp_and_duration_;
+
   GOOGLE_DISALLOW_IMPLICIT_CONSTRUCTORS(ProtoStreamObjectSource);
 };
 
 }  // namespace converter
 }  // namespace util
 }  // namespace protobuf
 
 }  // namespace google
 #endif  // GOOGLE_PROTOBUF_UTIL_CONVERTER_PROTOSTREAM_OBJECTSOURCE_H__