third_party/protobuf: Update to HEAD (83d681ee2c)

third_party/protobuf/src/google/protobuf/message_lite.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 21 matching lines @@
 //          kenton@google.com (Kenton Varda)
 //  Based on original Protocol Buffers design by
 //  Sanjay Ghemawat, Jeff Dean, and others.
 //
 // Defines MessageLite, the abstract interface implemented by all (lite
 // and non-lite) protocol message objects.
 
 #ifndef GOOGLE_PROTOBUF_MESSAGE_LITE_H__
 #define GOOGLE_PROTOBUF_MESSAGE_LITE_H__
 
+#include <climits>
 #include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/logging.h>
 
 
 namespace google {
 namespace protobuf {
   class Arena;
 namespace io {
   class CodedInputStream;
   class CodedOutputStream;
   class ZeroCopyInputStream;
   class ZeroCopyOutputStream;
 }
+namespace internal {
+  class WireFormatLite;
+}
 
 // Interface to light weight protocol messages.
 //
 // This interface is implemented by all protocol message objects.  Non-lite
 // messages additionally implement the Message interface, which is a
 // subclass of MessageLite.  Use MessageLite instead when you only need
 // the subset of features which it supports -- namely, nothing that uses
 // descriptors or reflection.  You can instruct the protocol compiler
 // to generate classes which implement only MessageLite, not the full
 // Message interface, by adding the following line to the .proto file:
 //
 //   option optimize_for = LITE_RUNTIME;
 //
 // This is particularly useful on resource-constrained systems where
 // the full protocol buffers runtime library is too big.
 //
 // Note that on non-constrained systems (e.g. servers) when you need
 // to link in lots of protocol definitions, a better way to reduce
 // total code footprint is to use optimize_for = CODE_SIZE.  This
 // will make the generated code smaller while still supporting all the
 // same features (at the expense of speed).  optimize_for = LITE_RUNTIME
 // is best when you only have a small number of message types linked
 // into your binary, in which case the size of the protocol buffers
 // runtime itself is the biggest problem.
 class LIBPROTOBUF_EXPORT MessageLite {
  public:
   inline MessageLite() {}
-  virtual ~MessageLite();
+  virtual ~MessageLite() {}
 
   // Basic Operations ------------------------------------------------
 
   // Get the name of this message type, e.g. "foo.bar.BazProto".
   virtual string GetTypeName() const = 0;
 
   // Construct a new instance of the same type.  Ownership is passed to the
   // caller.
   virtual MessageLite* New() const = 0;
 
@@ skipping 137 matching lines @@
   // Like SerializeAsString(), but allows missing required fields.
   string SerializePartialAsString() const;
 
   // Like SerializeToString(), but appends to the data to the string's existing
   // contents.  All required fields must be set.
   bool AppendToString(string* output) const;
   // Like AppendToString(), but allows missing required fields.
   bool AppendPartialToString(string* output) const;
 
   // Computes the serialized size of the message.  This recursively calls
-  // ByteSize() on all embedded messages.  If a subclass does not override
-  // this, it MUST override SetCachedSize().
+  // ByteSizeLong() on all embedded messages.
   //
-  // ByteSize() is generally linear in the number of fields defined for the
+  // ByteSizeLong() is generally linear in the number of fields defined for the
   // proto.
-  virtual int ByteSize() const = 0;
+  virtual size_t ByteSizeLong() const = 0;
 
-  // Serializes the message without recomputing the size.  The message must
-  // not have changed since the last call to ByteSize(); if it has, the results
-  // are undefined.
+  // Legacy ByteSize() API.
+  int ByteSize() const {
+    size_t result = ByteSizeLong();
+    GOOGLE_DCHECK_LE(result, static_cast<size_t>(INT_MAX));
+    return static_cast<int>(result);
+  }
+
+  // Serializes the message without recomputing the size.  The message must not
+  // have changed since the last call to ByteSize(), and the value returned by
+  // ByteSize must be non-negative.  Otherwise the results are undefined.
   virtual void SerializeWithCachedSizes(
       io::CodedOutputStream* output) const = 0;
 
-  // Like SerializeWithCachedSizes, but writes directly to *target, returning
-  // a pointer to the byte immediately after the last byte written.  "target"
-  // must point at a byte array of at least ByteSize() bytes.
-  virtual uint8* SerializeWithCachedSizesToArray(uint8* target) const;
+  // A version of SerializeWithCachedSizesToArray, below, that does
+  // not guarantee deterministic serialization.
+  virtual uint8* SerializeWithCachedSizesToArray(uint8* target) const {
+    return InternalSerializeWithCachedSizesToArray(false, target);
+  }
 
   // Returns the result of the last call to ByteSize().  An embedded message's
   // size is needed both to serialize it (because embedded messages are
   // length-delimited) and to compute the outer message's size.  Caching
   // the size avoids computing it multiple times.
   //
   // ByteSize() does not automatically use the cached size when available
   // because this would require invalidating it every time the message was
   // modified, which would be too hard and expensive.  (E.g. if a deeply-nested
   // sub-message is changed, all of its parents' cached sizes would need to be
   // invalidated, which is too much work for an otherwise inlined setter
   // method.)
   virtual int GetCachedSize() const = 0;
 
+  // Functions below here are not part of the public interface.  It isn't
+  // enforced, but they should be treated as private, and will be private
+  // at some future time.  Unfortunately the implementation of the "friend"
+  // keyword in GCC is broken at the moment, but we expect it will be fixed.
+
+  // Like SerializeWithCachedSizes, but writes directly to *target, returning
+  // a pointer to the byte immediately after the last byte written.  "target"
+  // must point at a byte array of at least ByteSize() bytes.  If deterministic
+  // is true then we use deterministic serialization, e.g., map keys are sorted.
+  // FOR INTERNAL USE ONLY!
+  virtual uint8* InternalSerializeWithCachedSizesToArray(bool deterministic,
+                                                         uint8* target) const;
+
  private:
+  friend class internal::WireFormatLite;
+
   GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MessageLite);
 };
 
 }  // namespace protobuf
 
 }  // namespace google
 #endif  // GOOGLE_PROTOBUF_MESSAGE_LITE_H__