third_party/protobuf: Update to HEAD (83d681ee2c)

third_party/protobuf/src/google/protobuf/unknown_field_set.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 34 matching lines @@
 #include <google/protobuf/stubs/logging.h>
 
 namespace google {
 namespace protobuf {
   namespace io {
     class CodedInputStream;         // coded_stream.h
     class CodedOutputStream;        // coded_stream.h
     class ZeroCopyInputStream;      // zero_copy_stream.h
   }
   namespace internal {
+    class InternalMetadataWithArena;  // metadata.h
     class WireFormat;               // wire_format.h
     class MessageSetFieldSkipperUsingCord;
                                     // extension_set_heavy.cc
   }
 
 class Message;                      // message.h
 class UnknownField;                 // below
 
 // An UnknownFieldSet contains fields that were encountered while parsing a
 // message but were not defined by its type.  Keeping track of these can be
@@ skipping 20 matching lines @@
 
   // Is this set empty?
   inline bool empty() const;
 
   // Merge the contents of some other UnknownFieldSet with this one.
   void MergeFrom(const UnknownFieldSet& other);
 
   // Similar to above, but this function will destroy the contents of other.
   void MergeFromAndDestroy(UnknownFieldSet* other);
 
+  // Merge the contents an UnknownFieldSet with the UnknownFieldSet in
+  // *metadata, if there is one.  If *metadata doesn't have an UnknownFieldSet
+  // then add one to it and make it be a copy of the first arg.
+  static void MergeToInternalMetdata(
+      const UnknownFieldSet& other,
+      internal::InternalMetadataWithArena* metadata);
+
   // Swaps the contents of some other UnknownFieldSet with this one.
   inline void Swap(UnknownFieldSet* x);
 
   // Computes (an estimate of) the total number of bytes currently used for
   // storing the unknown fields in memory. Does NOT include
   // sizeof(*this) in the calculation.
   int SpaceUsedExcludingSelf() const;
 
   // Version of SpaceUsed() including sizeof(*this).
   int SpaceUsed() const;
@@ skipping 63 matching lines @@
 class LIBPROTOBUF_EXPORT UnknownField {
  public:
   enum Type {
     TYPE_VARINT,
     TYPE_FIXED32,
     TYPE_FIXED64,
     TYPE_LENGTH_DELIMITED,
     TYPE_GROUP
   };
 
-  // The field's tag number, as seen on the wire.
+  // The field's field number, as seen on the wire.
   inline int number() const;
 
   // The field type.
   inline Type type() const;
 
   // Accessors -------------------------------------------------------
   // Each method works only for UnknownFields of the corresponding type.
 
   inline uint64 varint() const;
   inline uint32 fixed32() const;
   inline uint64 fixed64() const;
   inline const string& length_delimited() const;
   inline const UnknownFieldSet& group() const;
 
   inline void set_varint(uint64 value);
   inline void set_fixed32(uint32 value);
   inline void set_fixed64(uint64 value);
   inline void set_length_delimited(const string& value);
   inline string* mutable_length_delimited();
   inline UnknownFieldSet* mutable_group();
 
   // Serialization API.
   // These methods can take advantage of the underlying implementation and may
   // archieve a better performance than using getters to retrieve the data and
   // do the serialization yourself.
   void SerializeLengthDelimitedNoTag(io::CodedOutputStream* output) const;
   uint8* SerializeLengthDelimitedNoTagToArray(uint8* target) const;
 
-  inline int GetLengthDelimitedSize() const;
+  inline size_t GetLengthDelimitedSize() const;
 
  private:
   friend class UnknownFieldSet;
 
   // If this UnknownField contains a pointer, delete it.
   void Delete();
 
   // Reset all the underlying pointers to NULL. A special function to be only
   // used while merging from a temporary UFS.
   void Reset();
@@ skipping 16 matching lines @@
     uint32 fixed32_;
     uint64 fixed64_;
     mutable union LengthDelimited length_delimited_;
     UnknownFieldSet* group_;
   };
 };
 
 // ===================================================================
 // inline implementations
 
+inline UnknownFieldSet::UnknownFieldSet() : fields_(NULL) {}
+
+inline UnknownFieldSet::~UnknownFieldSet() { Clear(); }
+
+inline void UnknownFieldSet::ClearAndFreeMemory() { Clear(); }
+
 inline void UnknownFieldSet::Clear() {
-  if (fields_) {
+  if (fields_ != NULL) {
     ClearFallback();
   }
 }
 
 inline bool UnknownFieldSet::empty() const {
   // Invariant: fields_ is never empty if present.
   return !fields_;
 }
 
 inline void UnknownFieldSet::Swap(UnknownFieldSet* x) {
@@ skipping 61 matching lines @@
 }
 inline string* UnknownField::mutable_length_delimited() {
   assert(type() == TYPE_LENGTH_DELIMITED);
   return length_delimited_.string_value_;
 }
 inline UnknownFieldSet* UnknownField::mutable_group() {
   assert(type() == TYPE_GROUP);
   return group_;
 }
 
-inline int UnknownField::GetLengthDelimitedSize() const {
+inline size_t UnknownField::GetLengthDelimitedSize() const {
   GOOGLE_DCHECK_EQ(TYPE_LENGTH_DELIMITED, type());
-  return static_cast<int>(length_delimited_.string_value_->size());
+  return length_delimited_.string_value_->size();
 }
 
 inline void UnknownField::SetType(Type type) {
   type_ = type;
 }
 
 
 }  // namespace protobuf
 
 }  // namespace google
 #endif  // GOOGLE_PROTOBUF_UNKNOWN_FIELD_SET_H__