third_party/protobuf: Update to HEAD (83d681ee2c)

third_party/protobuf/src/google/protobuf/wire_format.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 67 matching lines @@
   // Given a field return its WireType
   static inline WireFormatLite::WireType WireTypeForField(
       const FieldDescriptor* field);
 
   // Given a FieldDescriptor::Type return its WireType
   static inline WireFormatLite::WireType WireTypeForFieldType(
       FieldDescriptor::Type type);
 
   // Compute the byte size of a tag.  For groups, this includes both the start
   // and end tags.
-  static inline int TagSize(int field_number, FieldDescriptor::Type type);
+  static inline size_t TagSize(int field_number, FieldDescriptor::Type type);
 
   // These procedures can be used to implement the methods of Message which
   // handle parsing and serialization of the protocol buffer wire format
   // using only the Reflection interface.  When you ask the protocol
   // compiler to optimize for code size rather than speed, it will implement
   // those methods in terms of these procedures.  Of course, these are much
   // slower than the specialized implementations which the protocol compiler
   // generates when told to optimize for speed.
 
   // Read a message in protocol buffer wire format.
@@ skipping 16 matching lines @@
   // These return false iff the underlying stream returns a write error.
   static void SerializeWithCachedSizes(
       const Message& message,
       int size, io::CodedOutputStream* output);
 
   // Implements Message::ByteSize() via reflection.  WARNING:  The result
   // of this method is *not* cached anywhere.  However, all embedded messages
   // will have their ByteSize() methods called, so their sizes will be cached.
   // Therefore, calling this method is sufficient to allow you to call
   // WireFormat::SerializeWithCachedSizes() on the same object.
-  static int ByteSize(const Message& message);
+  static size_t ByteSize(const Message& message);
 
   // -----------------------------------------------------------------
   // Helpers for dealing with unknown fields
 
   // Skips a field value of the given WireType.  The input should start
   // positioned immediately after the tag.  If unknown_fields is non-NULL,
   // the contents of the field will be added to it.
   static bool SkipField(io::CodedInputStream* input, uint32 tag,
                         UnknownFieldSet* unknown_fields);
 
@@ skipping 30 matching lines @@
   // Same as above, except writing directly to the provided buffer.
   // Requires that the buffer have sufficient capacity for
   // ComputeUnknownMessageSetItemsSize(unknown_fields).
   //
   // Returns a pointer past the last written byte.
   static uint8* SerializeUnknownMessageSetItemsToArray(
       const UnknownFieldSet& unknown_fields,
       uint8* target);
 
   // Compute the size of the UnknownFieldSet on the wire.
-  static int ComputeUnknownFieldsSize(const UnknownFieldSet& unknown_fields);
+  static size_t ComputeUnknownFieldsSize(const UnknownFieldSet& unknown_fields);
 
   // Same thing except for messages that have the message_set_wire_format
   // option.
-  static int ComputeUnknownMessageSetItemsSize(
+  static size_t ComputeUnknownMessageSetItemsSize(
       const UnknownFieldSet& unknown_fields);
 
 
   // Helper functions for encoding and decoding tags.  (Inlined below and in
   // _inl.h)
   //
   // This is different from MakeTag(field->number(), field->type()) in the case
   // of packed repeated fields.
   static uint32 MakeTag(const FieldDescriptor* field);
 
   // Parse a single field.  The input should start out positioned immediately
   // after the tag.
   static bool ParseAndMergeField(
       uint32 tag,
       const FieldDescriptor* field,        // May be NULL for unknown
       Message* message,
       io::CodedInputStream* input);
 
   // Serialize a single field.
   static void SerializeFieldWithCachedSizes(
       const FieldDescriptor* field,        // Cannot be NULL
       const Message& message,
       io::CodedOutputStream* output);
 
   // Compute size of a single field.  If the field is a message type, this
   // will call ByteSize() for the embedded message, insuring that it caches
   // its size.
-  static int FieldByteSize(
+  static size_t FieldByteSize(
       const FieldDescriptor* field,        // Cannot be NULL
       const Message& message);
 
   // Parse/serialize a MessageSet::Item group.  Used with messages that use
   // opion message_set_wire_format = true.
   static bool ParseAndMergeMessageSetItem(
       io::CodedInputStream* input,
       Message* message);
   static void SerializeMessageSetItemWithCachedSizes(
       const FieldDescriptor* field,
       const Message& message,
       io::CodedOutputStream* output);
-  static int MessageSetItemByteSize(
+  static size_t MessageSetItemByteSize(
       const FieldDescriptor* field,
       const Message& message);
 
   // Computes the byte size of a field, excluding tags. For packed fields, it
   // only includes the size of the raw data, and not the size of the total
   // length, but for other length-delimited types, the size of the length is
   // included.
-  static int FieldDataOnlyByteSize(
+  static size_t FieldDataOnlyByteSize(
       const FieldDescriptor* field,        // Cannot be NULL
       const Message& message);
 
   enum Operation {
     PARSE = 0,
     SERIALIZE = 1,
   };
 
   // Verifies that a string field is valid UTF8, logging an error if not.
   // This function will not be called by newly generated protobuf code
@@ skipping 54 matching lines @@
   // int first.
   return WireFormatLite::WireTypeForFieldType(
       static_cast<WireFormatLite::FieldType>(
         implicit_cast<int>(type)));
 }
 
 inline uint32 WireFormat::MakeTag(const FieldDescriptor* field) {
   return WireFormatLite::MakeTag(field->number(), WireTypeForField(field));
 }
 
-inline int WireFormat::TagSize(int field_number, FieldDescriptor::Type type) {
+inline size_t WireFormat::TagSize(int field_number,
+                                  FieldDescriptor::Type type) {
   // Some compilers don't like enum -> enum casts, so we implicit_cast to
   // int first.
   return WireFormatLite::TagSize(field_number,
       static_cast<WireFormatLite::FieldType>(
         implicit_cast<int>(type)));
 }
 
 inline void WireFormat::VerifyUTF8String(const char* data, int size,
     WireFormat::Operation op) {
 #ifdef GOOGLE_PROTOBUF_UTF8_VALIDATION_ENABLED
   WireFormatLite::VerifyUtf8String(
       data, size, static_cast<WireFormatLite::Operation>(op), NULL);
 #else
-  // Avoid the compiler warning about unsued variables.
+  // Avoid the compiler warning about unused variables.
   (void)data; (void)size; (void)op;
 #endif
 }
 
 inline void WireFormat::VerifyUTF8StringNamedField(
     const char* data, int size, WireFormat::Operation op,
     const char* field_name) {
 #ifdef GOOGLE_PROTOBUF_UTF8_VALIDATION_ENABLED
   WireFormatLite::VerifyUtf8String(
       data, size, static_cast<WireFormatLite::Operation>(op), field_name);
 #endif
 }
 
 
 }  // namespace internal
 }  // namespace protobuf
 
 }  // namespace google
 #endif  // GOOGLE_PROTOBUF_WIRE_FORMAT_H__