third_party/protobuf: Update to HEAD (f52e188fe4)

third_party/protobuf/src/google/protobuf/arenastring.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 19 matching lines @@
 
 #ifndef GOOGLE_PROTOBUF_ARENASTRING_H__
 #define GOOGLE_PROTOBUF_ARENASTRING_H__
 
 #include <string>
 
 #include <google/protobuf/stubs/logging.h>
 #include <google/protobuf/stubs/common.h>
 #include <google/protobuf/stubs/fastmem.h>
 #include <google/protobuf/arena.h>
-#include <google/protobuf/generated_message_util.h>
 
 
 
 // This is the implementation of arena string fields written for the open-source
 // release. The ArenaStringPtr struct below is an internal implementation class
 // and *should not be used* by user code. It is used to collect string
 // operations together into one place and abstract away the underlying
 // string-field pointer representation, so that (for example) an alternate
 // implementation that knew more about ::std::string's internals could integrate more
 // closely with the arena allocator.
 
 namespace google {
 namespace protobuf {
 namespace internal {
 
 struct LIBPROTOBUF_EXPORT ArenaStringPtr {
   inline void Set(const ::std::string* default_value,
                   const ::std::string& value, ::google::protobuf::Arena* arena) {
     if (ptr_ == default_value) {
       CreateInstance(arena, &value);
     } else {
       *ptr_ = value;
     }
   }
 
   // Basic accessors.
-  inline const ::std::string& Get(const ::std::string* /* default_value */) const {
-    return *ptr_;
-  }
+  inline const ::std::string& Get() const { return *ptr_; }
 
   inline ::std::string* Mutable(const ::std::string* default_value,
                            ::google::protobuf::Arena* arena) {
     if (ptr_ == default_value) {
       CreateInstance(arena, default_value);
     }
     return ptr_;
   }
 
   // Release returns a ::std::string* instance that is heap-allocated and is not
@@ skipping 63 matching lines @@
     }
   }
 
   // Swaps internal pointers. Arena-safety semantics: this is guarded by the
   // logic in Swap()/UnsafeArenaSwap() at the message level, so this method is
   // 'unsafe' if called directly.
   GOOGLE_ATTRIBUTE_ALWAYS_INLINE void Swap(ArenaStringPtr* other) {
     std::swap(ptr_, other->ptr_);
   }
 
-  // Frees storage (if not on an arena) and sets field to default value.
+  // Frees storage (if not on an arena).
   inline void Destroy(const ::std::string* default_value,
                       ::google::protobuf::Arena* arena) {
     if (arena == NULL && ptr_ != default_value) {
       delete ptr_;
     }
-    ptr_ = const_cast< ::std::string* >(default_value);
   }
 
   // Clears content, but keeps allocated string if arena != NULL, to avoid the
   // overhead of heap operations. After this returns, the content (as seen by
   // the user) will always be the empty string. Assumes that |default_value|
   // is an empty string.
   inline void ClearToEmpty(const ::std::string* default_value,
                            ::google::protobuf::Arena* /* arena */) {
     if (ptr_ == default_value) {
       // Already set to default (which is empty) -- do nothing.
@@ skipping 37 matching lines @@
   // tagged-pointer manipulations to be avoided.
   inline void SetNoArena(const ::std::string* default_value,
                          const ::std::string& value) {
     if (ptr_ == default_value) {
       CreateInstanceNoArena(&value);
     } else {
       *ptr_ = value;
     }
   }
 
+#if LANG_CXX11
+  void SetNoArena(const ::std::string* default_value, ::std::string&& value) {
+    if (IsDefault(default_value)) {
+      ptr_ = new ::std::string(std::move(value));
+    } else {
+      *ptr_ = std::move(value);
+    }
+  }
+#endif
+
   void AssignWithDefault(const ::std::string* default_value, ArenaStringPtr value);
 
-  inline const ::std::string& GetNoArena(const ::std::string* /* default_value */) const {
-    return *ptr_;
-  }
+  inline const ::std::string& GetNoArena() const { return *ptr_; }
 
   ::std::string* MutableNoArena(const ::std::string* default_value);
 
   inline ::std::string* ReleaseNoArena(const ::std::string* default_value) {
     if (ptr_ == default_value) {
       return NULL;
     } else {
       ::std::string* released = ptr_;
       ptr_ = const_cast< ::std::string* >(default_value);
       return released;
@@ skipping 32 matching lines @@
   }
 
   // Internal accessor used only at parse time to provide direct access to the
   // raw pointer from the shared parse routine (in the non-arenas case). The
   // parse routine does the string allocation in order to save code size in the
   // generated parsing code.
   inline ::std::string** UnsafeRawStringPointer() {
     return &ptr_;
   }
 
+  inline bool IsDefault(const ::std::string* default_value) const {
+    return ptr_ == default_value;
+  }
+
  private:
   ::std::string* ptr_;
 
   GOOGLE_ATTRIBUTE_NOINLINE void CreateInstance(::google::protobuf::Arena* arena,
                                          const ::std::string* initial_value) {
-    // Assumes ptr_ is not NULL.
-    if (initial_value != NULL) {
-      ptr_ = new ::std::string(*initial_value);
-    } else {
-      ptr_ = new ::std::string();
-    }
+    GOOGLE_DCHECK(initial_value != NULL);
+    ptr_ = new ::std::string(*initial_value);
     if (arena != NULL) {
       arena->Own(ptr_);
     }
   }
   GOOGLE_ATTRIBUTE_NOINLINE void CreateInstanceNoArena(const ::std::string* initial_value) {
-    if (initial_value != NULL) {
-      ptr_ = new ::std::string(*initial_value);
-    } else {
-      ptr_ = new ::std::string();
-    }
+    GOOGLE_DCHECK(initial_value != NULL);
+    ptr_ = new ::std::string(*initial_value);
   }
 };
 
 }  // namespace internal
 }  // namespace protobuf
 
 
 
 }  // namespace google
 #endif  // GOOGLE_PROTOBUF_ARENASTRING_H__