src/google/protobuf/inlined_string_field.h - platform/prebuilts/libprotobuf/linux - Git at Google

 // 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.
 //     * Redistributions in binary form must reproduce the above
 // copyright notice, this list of conditions and the following disclaimer
 // in the documentation and/or other materials provided with the
 // distribution.
 //     * Neither the name of Google Inc. nor the names of its
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 #ifndef GOOGLE_PROTOBUF_INLINED_STRING_FIELD_H__
 #define GOOGLE_PROTOBUF_INLINED_STRING_FIELD_H__

 #include <string>
 #include <utility>

 #include <google/protobuf/stubs/logging.h>
 #include <google/protobuf/stubs/common.h>
 #include <google/protobuf/port.h>
 #include <google/protobuf/stubs/strutil.h>
 #include <google/protobuf/arenastring.h>
 #include <google/protobuf/message_lite.h>

 // Must be included last.
 #include <google/protobuf/port_def.inc>

 #ifdef SWIG
 #error "You cannot SWIG proto headers"
 #endif

 namespace google {
 namespace protobuf {

 class Arena;

 namespace internal {

 // InlinedStringField wraps a std::string instance and exposes an API similar to
 // ArenaStringPtr's wrapping of a std::string* instance.
 //
 // default_value parameters are taken for consistency with ArenaStringPtr, but
 // are not used for most methods. With inlining, these should be removed from
 // the generated binary.
 //
 // InlinedStringField has a donating mechanism that allows string buffer
 // allocated on arena. A string is donated means both the string container and
 // the data buffer are on arena. The donating mechanism here is similar to the
 // one in ArenaStringPtr with some differences:
 //
 // When an InlinedStringField is constructed, the donating state is true. This
 // is because the string container is directly stored in the message on the
 // arena:
 //
 //   Construction: donated=true
 //   Arena:
 //   +-----------------------+
 //   |Message foo:           |
 //   | +-------------------+ |
 //   | |InlinedStringField:| |
 //   | | +-----+           | |
 //   | | | | | |           | |
 //   | | +-----+           | |
 //   | +-------------------+ |
 //   +-----------------------+
 //
 // When lvalue Set is called, the donating state is still true. String data will
 // be allocated on the arena:
 //
 //   Lvalue Set: donated=true
 //   Arena:
 //   +-----------------------+
 //   |Message foo:           |
 //   | +-------------------+ |
 //   | |InlinedStringField:| |
 //   | | +-----+           | |
 //   | | | | | |           | |
 //   | | +|----+           | |
 //   | +--|----------------+ |
 //   |    V                  |
 //   |  +----------------+   |
 //   |  |'f','o','o',... |   |
 //   |  +----------------+   |
 //   +-----------------------+
 //
 // Some operations will undonate a donated string, including: Mutable,
 // SetAllocated, Rvalue Set, and Swap with a non-donated string.
 //
 // For more details of the donating states transitions, go/pd-inlined-string.
 class PROTOBUF_EXPORT InlinedStringField {
  public:
   InlinedStringField() { Init(); }
   inline void Init() { new (get_mutable()) std::string(); }
   // Add the dummy parameter just to make InlinedStringField(nullptr)
   // unambiguous.
   constexpr InlinedStringField(
       const ExplicitlyConstructed<std::string>* /*default_value*/,
       bool /*dummy*/)
       : value_{} {}
   explicit InlinedStringField(const std::string& default_value);
   explicit InlinedStringField(Arena* arena);
   ~InlinedStringField() { Destruct(); }

   // Lvalue Set. To save space, we pack the donating states of multiple
   // InlinedStringFields into an uint32_t `donating_states`. The `mask`
   // indicates the position of the bit for this InlinedStringField. `donated` is
   // whether this field is donated.
   //
   // The caller should guarantee that:
   //
   //   `donated == ((donating_states & ~mask) != 0)`
   //
   // This method never changes the `donating_states`.
   void Set(ConstStringParam value, Arena* arena, bool donated,
            uint32_t* donating_states, uint32_t mask, MessageLite* msg);

   // Rvalue Set. If this field is donated, this method will undonate this field
   // by mutating the `donating_states` according to `mask`.
   void Set(std::string&& value, Arena* arena, bool donated,
            uint32_t* donating_states, uint32_t mask, MessageLite* msg);

   void Set(const char* str, ::google::protobuf::Arena* arena, bool donated,
            uint32_t* donating_states, uint32_t mask, MessageLite* msg);

   void Set(const char* str, size_t size, ::google::protobuf::Arena* arena, bool donated,
            uint32_t* donating_states, uint32_t mask, MessageLite* msg);

   template <typename RefWrappedType>
   void Set(std::reference_wrapper<RefWrappedType> const_string_ref,
            ::google::protobuf::Arena* arena, bool donated, uint32_t* donating_states,
            uint32_t mask, MessageLite* msg);

   void SetBytes(ConstStringParam value, Arena* arena, bool donated,
                 uint32_t* donating_states, uint32_t mask, MessageLite* msg);

   void SetBytes(std::string&& value, Arena* arena, bool donated,
                 uint32_t* donating_states, uint32_t mask, MessageLite* msg);

   void SetBytes(const char* str, ::google::protobuf::Arena* arena, bool donated,
                 uint32_t* donating_states, uint32_t mask, MessageLite* msg);

   void SetBytes(const void* p, size_t size, ::google::protobuf::Arena* arena,
                 bool donated, uint32_t* donating_states, uint32_t mask,
                 MessageLite* msg);

   template <typename RefWrappedType>
   void SetBytes(std::reference_wrapper<RefWrappedType> const_string_ref,
                 ::google::protobuf::Arena* arena, bool donated, uint32_t* donating_states,
                 uint32_t mask, MessageLite* msg);

   PROTOBUF_NDEBUG_INLINE void SetNoArena(StringPiece value);
   PROTOBUF_NDEBUG_INLINE void SetNoArena(std::string&& value);

   // Basic accessors.
   PROTOBUF_NDEBUG_INLINE const std::string& Get() const { return GetNoArena(); }
   PROTOBUF_NDEBUG_INLINE const std::string& GetNoArena() const;

   // Mutable returns a std::string* instance that is heap-allocated. If this
   // field is donated, this method undonates this field by mutating the
   // `donating_states` according to `mask`, and copies the content of the
   // original string to the returning string.
   std::string* Mutable(Arena* arena, bool donated, uint32_t* donating_states,
                        uint32_t mask, MessageLite* msg);
   std::string* Mutable(const LazyString& default_value, Arena* arena,
                        bool donated, uint32_t* donating_states, uint32_t mask,
                        MessageLite* msg);

   // Mutable(nullptr_t) is an overload to explicitly support Mutable(nullptr)
   // calls used by the internal parser logic. This provides API equivalence with
   // ArenaStringPtr, while still protecting against calls with arena pointers.
   std::string* Mutable(std::nullptr_t);
   std::string* MutableNoCopy(std::nullptr_t);

   // Takes a std::string that is heap-allocated, and takes ownership. The
   // std::string's destructor is registered with the arena. Used to implement
   // set_allocated_<field> in generated classes.
   //
   // If this field is donated, this method undonates this field by mutating the
   // `donating_states` according to `mask`.
   void SetAllocated(const std::string* default_value, std::string* value,
                     Arena* arena, bool donated, uint32_t* donating_states,
                     uint32_t mask, MessageLite* msg);

   void SetAllocatedNoArena(const std::string* default_value,
                            std::string* value);

   // Release returns a std::string* instance that is heap-allocated and is not
   // Own()'d by any arena. If the field is not set, this returns nullptr. The
   // caller retains ownership. Clears this field back to nullptr state. Used to
   // implement release_<field>() methods on generated classes.
   PROTOBUF_NODISCARD std::string* Release(Arena* arena, bool donated);
   PROTOBUF_NODISCARD std::string* Release();

   // --------------------------------------------------------
   // Below functions will be removed in subsequent code change
   // --------------------------------------------------------
 #ifdef DEPRECATED_METHODS_TO_BE_DELETED
   PROTOBUF_NODISCARD std::string* Release(const std::string*, Arena* arena,
                                           bool donated) {
     return Release(arena, donated);
   }

   PROTOBUF_NODISCARD std::string* ReleaseNonDefault(const std::string*,
                                                     Arena* arena) {
     return Release();
   }

   std::string* ReleaseNonDefaultNoArena(const std::string* default_value) {
     return Release();
   }

   void Set(const std::string*, ConstStringParam value, Arena* arena,
            bool donated, uint32_t* donating_states, uint32_t mask,
            MessageLite* msg) {
     Set(value, arena, donated, donating_states, mask, msg);
   }

   void Set(const std::string*, std::string&& value, Arena* arena, bool donated,
            uint32_t* donating_states, uint32_t mask, MessageLite* msg) {
     Set(std::move(value), arena, donated, donating_states, mask, msg);
   }


   template <typename FirstParam>
   void Set(FirstParam, const char* str, ::google::protobuf::Arena* arena, bool donated,
            uint32_t* donating_states, uint32_t mask, MessageLite* msg) {
     Set(str, arena, donated, donating_states, mask, msg);
   }

   template <typename FirstParam>
   void Set(FirstParam p1, const char* str, size_t size, ::google::protobuf::Arena* arena,
            bool donated, uint32_t* donating_states, uint32_t mask,
            MessageLite* msg) {
     Set(str, size, arena, donated, donating_states, mask, msg);
   }

   template <typename FirstParam, typename RefWrappedType>
   void Set(FirstParam p1,
            std::reference_wrapper<RefWrappedType> const_string_ref,
            ::google::protobuf::Arena* arena, bool donated, uint32_t* donating_states,
            uint32_t mask, MessageLite* msg) {
     Set(const_string_ref, arena, donated, donating_states, mask, msg);
   }

   void SetBytes(const std::string*, ConstStringParam value, Arena* arena,
                 bool donated, uint32_t* donating_states, uint32_t mask,
                 MessageLite* msg) {
     Set(value, arena, donated, donating_states, mask, msg);
   }


   void SetBytes(const std::string*, std::string&& value, Arena* arena,
                 bool donated, uint32_t* donating_states, uint32_t mask,
                 MessageLite* msg) {
     Set(std::move(value), arena, donated, donating_states, mask, msg);
   }

   template <typename FirstParam>
   void SetBytes(FirstParam p1, const char* str, ::google::protobuf::Arena* arena,
                 bool donated, uint32_t* donating_states, uint32_t mask,
                 MessageLite* msg) {
     SetBytes(str, arena, donated, donating_states, mask, msg);
   }

   template <typename FirstParam>
   void SetBytes(FirstParam p1, const void* p, size_t size,
                 ::google::protobuf::Arena* arena, bool donated, uint32_t* donating_states,
                 uint32_t mask, MessageLite* msg) {
     SetBytes(p, size, arena, donated, donating_states, mask, msg);
   }

   template <typename FirstParam, typename RefWrappedType>
   void SetBytes(FirstParam p1,
                 std::reference_wrapper<RefWrappedType> const_string_ref,
                 ::google::protobuf::Arena* arena, bool donated, uint32_t* donating_states,
                 uint32_t mask, MessageLite* msg) {
     SetBytes(const_string_ref.get(), arena, donated, donating_states, mask,
              msg);
   }

   void SetNoArena(const std::string*, StringPiece value) {
     SetNoArena(value);
   }
   void SetNoArena(const std::string*, std::string&& value) {
     SetNoArena(std::move(value));
   }

   std::string* Mutable(ArenaStringPtr::EmptyDefault, Arena* arena, bool donated,
                        uint32_t* donating_states, uint32_t mask,
                        MessageLite* msg) {
     return Mutable(arena, donated, donating_states, mask, msg);
   }

   PROTOBUF_NDEBUG_INLINE std::string* MutableNoArenaNoDefault(
       const std::string* /*default_value*/) {
     return MutableNoCopy(nullptr);
   }

 #endif  // DEPRECATED_METHODS_TO_BE_DELETED

   // Arena-safety semantics: this is guarded by the logic in
   // Swap()/UnsafeArenaSwap() at the message level, so this method is
   // 'unsafe' if called directly.
   inline PROTOBUF_NDEBUG_INLINE static void InternalSwap(
       InlinedStringField* lhs, Arena* lhs_arena, bool lhs_arena_dtor_registered,
       MessageLite* lhs_msg,  //
       InlinedStringField* rhs, Arena* rhs_arena, bool rhs_arena_dtor_registered,
       MessageLite* rhs_msg);

   // Frees storage (if not on an arena).
   PROTOBUF_NDEBUG_INLINE void Destroy(const std::string* default_value,
                                       Arena* arena) {
     if (arena == nullptr) {
       DestroyNoArena(default_value);
     }
   }
   PROTOBUF_NDEBUG_INLINE void DestroyNoArena(const std::string* default_value);

   // Clears content, but keeps allocated std::string, to avoid the overhead of
   // heap operations. After this returns, the content (as seen by the user) will
   // always be the empty std::string.
   PROTOBUF_NDEBUG_INLINE void ClearToEmpty() { ClearNonDefaultToEmpty(); }
   PROTOBUF_NDEBUG_INLINE void ClearNonDefaultToEmpty() {
     get_mutable()->clear();
   }

   // Clears content, but keeps allocated std::string if arena != nullptr, to
   // avoid the overhead of heap operations. After this returns, the content (as
   // seen by the user) will always be equal to |default_value|.
   void ClearToDefault(const LazyString& default_value, Arena* arena,
                       bool donated);

   // Generated code / reflection only! Returns a mutable pointer to the string.
   PROTOBUF_NDEBUG_INLINE std::string* UnsafeMutablePointer();

   // InlinedStringField doesn't have things like the `default_value` pointer in
   // ArenaStringPtr.
   static constexpr bool IsDefault() { return false; }
   static constexpr bool IsDefault(const std::string*) { return false; }

  private:
   void Destruct() { get_mutable()->~basic_string(); }

   PROTOBUF_NDEBUG_INLINE std::string* get_mutable();
   PROTOBUF_NDEBUG_INLINE const std::string* get_const() const;

   alignas(std::string) char value_[sizeof(std::string)];

   std::string* MutableSlow(::google::protobuf::Arena* arena, bool donated,
                            uint32_t* donating_states, uint32_t mask,
                            MessageLite* msg);


   // When constructed in an Arena, we want our destructor to be skipped.
   friend class ::google::protobuf::Arena;
   typedef void InternalArenaConstructable_;
   typedef void DestructorSkippable_;
 };

 inline std::string* InlinedStringField::get_mutable() {
   return reinterpret_cast<std::string*>(&value_);
 }

 inline const std::string* InlinedStringField::get_const() const {
   return reinterpret_cast<const std::string*>(&value_);
 }

 inline InlinedStringField::InlinedStringField(
     const std::string& default_value) {
   new (get_mutable()) std::string(default_value);
 }


 inline InlinedStringField::InlinedStringField(Arena* /*arena*/) { Init(); }

 inline const std::string& InlinedStringField::GetNoArena() const {
   return *get_const();
 }

 inline void InlinedStringField::SetAllocatedNoArena(
     const std::string* /*default_value*/, std::string* value) {
   if (value == nullptr) {
     // Currently, inlined string field can't have non empty default.
     get_mutable()->clear();
   } else {
     get_mutable()->assign(std::move(*value));
     delete value;
   }
 }

 inline void InlinedStringField::DestroyNoArena(const std::string*) {
   // This is invoked from the generated message's ArenaDtor, which is used to
   // clean up objects not allocated on the Arena.
   this->~InlinedStringField();
 }

 inline void InlinedStringField::SetNoArena(StringPiece value) {
   get_mutable()->assign(value.data(), value.length());
 }

 inline void InlinedStringField::SetNoArena(std::string&& value) {
   get_mutable()->assign(std::move(value));
 }

 // Caller should make sure rhs_arena allocated rhs, and lhs_arena allocated lhs.
 inline PROTOBUF_NDEBUG_INLINE void InlinedStringField::InternalSwap(
     InlinedStringField* lhs, Arena* lhs_arena, bool lhs_arena_dtor_registered,
     MessageLite* lhs_msg,  //
     InlinedStringField* rhs, Arena* rhs_arena, bool rhs_arena_dtor_registered,
     MessageLite* rhs_msg) {
 #if GOOGLE_PROTOBUF_INTERNAL_DONATE_STEAL_INLINE
   lhs->get_mutable()->swap(*rhs->get_mutable());
   if (!lhs_arena_dtor_registered && rhs_arena_dtor_registered) {
     lhs_msg->OnDemandRegisterArenaDtor(lhs_arena);
   } else if (lhs_arena_dtor_registered && !rhs_arena_dtor_registered) {
     rhs_msg->OnDemandRegisterArenaDtor(rhs_arena);
   }
 #else
   (void)lhs_arena;
   (void)rhs_arena;
   (void)lhs_arena_dtor_registered;
   (void)rhs_arena_dtor_registered;
   (void)lhs_msg;
   (void)rhs_msg;
   lhs->get_mutable()->swap(*rhs->get_mutable());
 #endif
 }

 inline void InlinedStringField::Set(ConstStringParam value, Arena* arena,
                                     bool donated, uint32_t* /*donating_states*/,
                                     uint32_t /*mask*/, MessageLite* /*msg*/) {
   (void)arena;
   (void)donated;
   SetNoArena(value);
 }

 inline void InlinedStringField::Set(const char* str, ::google::protobuf::Arena* arena,
                                     bool donated, uint32_t* donating_states,
                                     uint32_t mask, MessageLite* msg) {
   Set(ConstStringParam(str), arena, donated, donating_states, mask, msg);
 }

 inline void InlinedStringField::Set(const char* str, size_t size,
                                     ::google::protobuf::Arena* arena, bool donated,
                                     uint32_t* donating_states, uint32_t mask,
                                     MessageLite* msg) {
   Set(ConstStringParam{str, size}, arena, donated, donating_states, mask, msg);
 }

 inline void InlinedStringField::SetBytes(ConstStringParam value, Arena* arena,
                                          bool donated,
                                          uint32_t* donating_states,
                                          uint32_t mask, MessageLite* msg) {
   Set(value, arena, donated, donating_states, mask, msg);
 }

 inline void InlinedStringField::SetBytes(std::string&& value, Arena* arena,
                                          bool donated,
                                          uint32_t* donating_states,
                                          uint32_t mask, MessageLite* msg) {
   Set(std::move(value), arena, donated, donating_states, mask, msg);
 }

 inline void InlinedStringField::SetBytes(const char* str,
                                          ::google::protobuf::Arena* arena, bool donated,
                                          uint32_t* donating_states,
                                          uint32_t mask, MessageLite* msg) {
   Set(str, arena, donated, donating_states, mask, msg);
 }

 inline void InlinedStringField::SetBytes(const void* p, size_t size,
                                          ::google::protobuf::Arena* arena, bool donated,
                                          uint32_t* donating_states,
                                          uint32_t mask, MessageLite* msg) {
   Set(static_cast<const char*>(p), size, arena, donated, donating_states, mask,
       msg);
 }

 template <typename RefWrappedType>
 inline void InlinedStringField::Set(
     std::reference_wrapper<RefWrappedType> const_string_ref,
     ::google::protobuf::Arena* arena, bool donated, uint32_t* donating_states,
     uint32_t mask, MessageLite* msg) {
   Set(const_string_ref.get(), arena, donated, donating_states, mask, msg);
 }

 template <typename RefWrappedType>
 inline void InlinedStringField::SetBytes(
     std::reference_wrapper<RefWrappedType> const_string_ref,
     ::google::protobuf::Arena* arena, bool donated, uint32_t* donating_states,
     uint32_t mask, MessageLite* msg) {
   Set(const_string_ref.get(), arena, donated, donating_states, mask, msg);
 }

 inline std::string* InlinedStringField::UnsafeMutablePointer() {
   return get_mutable();
 }

 inline std::string* InlinedStringField::Mutable(std::nullptr_t) {
   return get_mutable();
 }

 inline std::string* InlinedStringField::MutableNoCopy(std::nullptr_t) {
   return get_mutable();
 }

 }  // namespace internal
 }  // namespace protobuf
 }  // namespace google

 #include <google/protobuf/port_undef.inc>

 #endif  // GOOGLE_PROTOBUF_INLINED_STRING_FIELD_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.
	// * Redistributions in binary form must reproduce the above
	// copyright notice, this list of conditions and the following disclaimer
	// in the documentation and/or other materials provided with the
	// distribution.
	// * Neither the name of Google Inc. nor the names of its
	// contributors may be used to endorse or promote products derived from
	// this software without specific prior written permission.
	//
	// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
	// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
	// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
	// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

	#ifndef GOOGLE_PROTOBUF_INLINED_STRING_FIELD_H__
	#define GOOGLE_PROTOBUF_INLINED_STRING_FIELD_H__

	#include <string>
	#include <utility>

	#include <google/protobuf/stubs/logging.h>
	#include <google/protobuf/stubs/common.h>
	#include <google/protobuf/port.h>
	#include <google/protobuf/stubs/strutil.h>
	#include <google/protobuf/arenastring.h>
	#include <google/protobuf/message_lite.h>

	// Must be included last.
	#include <google/protobuf/port_def.inc>

	#ifdef SWIG
	#error "You cannot SWIG proto headers"
	#endif

	namespace google {
	namespace protobuf {

	class Arena;

	namespace internal {

	// InlinedStringField wraps a std::string instance and exposes an API similar to
	// ArenaStringPtr's wrapping of a std::string* instance.
	//
	// default_value parameters are taken for consistency with ArenaStringPtr, but
	// are not used for most methods. With inlining, these should be removed from
	// the generated binary.
	//
	// InlinedStringField has a donating mechanism that allows string buffer
	// allocated on arena. A string is donated means both the string container and
	// the data buffer are on arena. The donating mechanism here is similar to the
	// one in ArenaStringPtr with some differences:
	//
	// When an InlinedStringField is constructed, the donating state is true. This
	// is because the string container is directly stored in the message on the
	// arena:
	//
	// Construction: donated=true
	// Arena:
	// +-----------------------+
	// \|Message foo: \|
	// \| +-------------------+ \|
	// \| \|InlinedStringField:\| \|
	// \| \| +-----+ \| \|
	// \| \| \| \| \| \| \| \|
	// \| \| +-----+ \| \|
	// \| +-------------------+ \|
	// +-----------------------+
	//
	// When lvalue Set is called, the donating state is still true. String data will
	// be allocated on the arena:
	//
	// Lvalue Set: donated=true
	// Arena:
	// +-----------------------+
	// \|Message foo: \|
	// \| +-------------------+ \|
	// \| \|InlinedStringField:\| \|
	// \| \| +-----+ \| \|
	// \| \| \| \| \| \| \| \|
	// \| \| +\|----+ \| \|
	// \| +--\|----------------+ \|
	// \| V \|
	// \| +----------------+ \|
	// \| \|'f','o','o',... \| \|
	// \| +----------------+ \|
	// +-----------------------+
	//
	// Some operations will undonate a donated string, including: Mutable,
	// SetAllocated, Rvalue Set, and Swap with a non-donated string.
	//
	// For more details of the donating states transitions, go/pd-inlined-string.
	class PROTOBUF_EXPORT InlinedStringField {
	public:
	InlinedStringField() { Init(); }
	inline void Init() { new (get_mutable()) std::string(); }
	// Add the dummy parameter just to make InlinedStringField(nullptr)
	// unambiguous.
	constexpr InlinedStringField(
	const ExplicitlyConstructed<std::string>* /default_value/,
	bool /dummy/)
	: value_{} {}
	explicit InlinedStringField(const std::string& default_value);
	explicit InlinedStringField(Arena* arena);
	~InlinedStringField() { Destruct(); }

	// Lvalue Set. To save space, we pack the donating states of multiple
	// InlinedStringFields into an uint32_t `donating_states`. The `mask`
	// indicates the position of the bit for this InlinedStringField. `donated` is
	// whether this field is donated.
	//
	// The caller should guarantee that:
	//
	// `donated == ((donating_states & ~mask) != 0)`
	//
	// This method never changes the `donating_states`.
	void Set(ConstStringParam value, Arena* arena, bool donated,
	uint32_t* donating_states, uint32_t mask, MessageLite* msg);

	// Rvalue Set. If this field is donated, this method will undonate this field
	// by mutating the `donating_states` according to `mask`.
	void Set(std::string&& value, Arena* arena, bool donated,
	uint32_t* donating_states, uint32_t mask, MessageLite* msg);

	void Set(const char* str, ::google::protobuf::Arena* arena, bool donated,
	uint32_t* donating_states, uint32_t mask, MessageLite* msg);

	void Set(const char* str, size_t size, ::google::protobuf::Arena* arena, bool donated,
	uint32_t* donating_states, uint32_t mask, MessageLite* msg);

	template <typename RefWrappedType>
	void Set(std::reference_wrapper<RefWrappedType> const_string_ref,
	::google::protobuf::Arena* arena, bool donated, uint32_t* donating_states,
	uint32_t mask, MessageLite* msg);

	void SetBytes(ConstStringParam value, Arena* arena, bool donated,
	uint32_t* donating_states, uint32_t mask, MessageLite* msg);

	void SetBytes(std::string&& value, Arena* arena, bool donated,
	uint32_t* donating_states, uint32_t mask, MessageLite* msg);

	void SetBytes(const char* str, ::google::protobuf::Arena* arena, bool donated,
	uint32_t* donating_states, uint32_t mask, MessageLite* msg);

	void SetBytes(const void* p, size_t size, ::google::protobuf::Arena* arena,
	bool donated, uint32_t* donating_states, uint32_t mask,
	MessageLite* msg);

	template <typename RefWrappedType>
	void SetBytes(std::reference_wrapper<RefWrappedType> const_string_ref,
	::google::protobuf::Arena* arena, bool donated, uint32_t* donating_states,
	uint32_t mask, MessageLite* msg);

	PROTOBUF_NDEBUG_INLINE void SetNoArena(StringPiece value);
	PROTOBUF_NDEBUG_INLINE void SetNoArena(std::string&& value);

	// Basic accessors.
	PROTOBUF_NDEBUG_INLINE const std::string& Get() const { return GetNoArena(); }
	PROTOBUF_NDEBUG_INLINE const std::string& GetNoArena() const;

	// Mutable returns a std::string* instance that is heap-allocated. If this
	// field is donated, this method undonates this field by mutating the
	// `donating_states` according to `mask`, and copies the content of the
	// original string to the returning string.
	std::string* Mutable(Arena* arena, bool donated, uint32_t* donating_states,
	uint32_t mask, MessageLite* msg);
	std::string* Mutable(const LazyString& default_value, Arena* arena,
	bool donated, uint32_t* donating_states, uint32_t mask,
	MessageLite* msg);

	// Mutable(nullptr_t) is an overload to explicitly support Mutable(nullptr)
	// calls used by the internal parser logic. This provides API equivalence with
	// ArenaStringPtr, while still protecting against calls with arena pointers.
	std::string* Mutable(std::nullptr_t);
	std::string* MutableNoCopy(std::nullptr_t);

	// Takes a std::string that is heap-allocated, and takes ownership. The
	// std::string's destructor is registered with the arena. Used to implement
	// set_allocated_<field> in generated classes.
	//
	// If this field is donated, this method undonates this field by mutating the
	// `donating_states` according to `mask`.
	void SetAllocated(const std::string* default_value, std::string* value,
	Arena* arena, bool donated, uint32_t* donating_states,
	uint32_t mask, MessageLite* msg);

	void SetAllocatedNoArena(const std::string* default_value,
	std::string* value);

	// Release returns a std::string* instance that is heap-allocated and is not
	// Own()'d by any arena. If the field is not set, this returns nullptr. The
	// caller retains ownership. Clears this field back to nullptr state. Used to
	// implement release_<field>() methods on generated classes.
	PROTOBUF_NODISCARD std::string* Release(Arena* arena, bool donated);
	PROTOBUF_NODISCARD std::string* Release();

	// --------------------------------------------------------
	// Below functions will be removed in subsequent code change
	// --------------------------------------------------------
	#ifdef DEPRECATED_METHODS_TO_BE_DELETED
	PROTOBUF_NODISCARD std::string* Release(const std::string, Arena arena,
	bool donated) {
	return Release(arena, donated);
	}

	PROTOBUF_NODISCARD std::string* ReleaseNonDefault(const std::string*,
	Arena* arena) {
	return Release();
	}

	std::string* ReleaseNonDefaultNoArena(const std::string* default_value) {
	return Release();
	}

	void Set(const std::string, ConstStringParam value, Arena arena,
	bool donated, uint32_t* donating_states, uint32_t mask,
	MessageLite* msg) {
	Set(value, arena, donated, donating_states, mask, msg);
	}

	void Set(const std::string, std::string&& value, Arena arena, bool donated,
	uint32_t* donating_states, uint32_t mask, MessageLite* msg) {
	Set(std::move(value), arena, donated, donating_states, mask, msg);
	}


	template <typename FirstParam>
	void Set(FirstParam, const char* str, ::google::protobuf::Arena* arena, bool donated,
	uint32_t* donating_states, uint32_t mask, MessageLite* msg) {
	Set(str, arena, donated, donating_states, mask, msg);
	}

	template <typename FirstParam>
	void Set(FirstParam p1, const char* str, size_t size, ::google::protobuf::Arena* arena,
	bool donated, uint32_t* donating_states, uint32_t mask,
	MessageLite* msg) {
	Set(str, size, arena, donated, donating_states, mask, msg);
	}

	template <typename FirstParam, typename RefWrappedType>
	void Set(FirstParam p1,
	std::reference_wrapper<RefWrappedType> const_string_ref,
	::google::protobuf::Arena* arena, bool donated, uint32_t* donating_states,
	uint32_t mask, MessageLite* msg) {
	Set(const_string_ref, arena, donated, donating_states, mask, msg);
	}

	void SetBytes(const std::string, ConstStringParam value, Arena arena,
	bool donated, uint32_t* donating_states, uint32_t mask,
	MessageLite* msg) {
	Set(value, arena, donated, donating_states, mask, msg);
	}


	void SetBytes(const std::string, std::string&& value, Arena arena,
	bool donated, uint32_t* donating_states, uint32_t mask,
	MessageLite* msg) {
	Set(std::move(value), arena, donated, donating_states, mask, msg);
	}

	template <typename FirstParam>
	void SetBytes(FirstParam p1, const char* str, ::google::protobuf::Arena* arena,
	bool donated, uint32_t* donating_states, uint32_t mask,
	MessageLite* msg) {
	SetBytes(str, arena, donated, donating_states, mask, msg);
	}

	template <typename FirstParam>
	void SetBytes(FirstParam p1, const void* p, size_t size,
	::google::protobuf::Arena* arena, bool donated, uint32_t* donating_states,
	uint32_t mask, MessageLite* msg) {
	SetBytes(p, size, arena, donated, donating_states, mask, msg);
	}

	template <typename FirstParam, typename RefWrappedType>
	void SetBytes(FirstParam p1,
	std::reference_wrapper<RefWrappedType> const_string_ref,
	::google::protobuf::Arena* arena, bool donated, uint32_t* donating_states,
	uint32_t mask, MessageLite* msg) {
	SetBytes(const_string_ref.get(), arena, donated, donating_states, mask,
	msg);
	}

	void SetNoArena(const std::string*, StringPiece value) {
	SetNoArena(value);
	}
	void SetNoArena(const std::string*, std::string&& value) {
	SetNoArena(std::move(value));
	}

	std::string* Mutable(ArenaStringPtr::EmptyDefault, Arena* arena, bool donated,
	uint32_t* donating_states, uint32_t mask,
	MessageLite* msg) {
	return Mutable(arena, donated, donating_states, mask, msg);
	}

	PROTOBUF_NDEBUG_INLINE std::string* MutableNoArenaNoDefault(
	const std::string* /default_value/) {
	return MutableNoCopy(nullptr);
	}

	#endif // DEPRECATED_METHODS_TO_BE_DELETED

	// Arena-safety semantics: this is guarded by the logic in
	// Swap()/UnsafeArenaSwap() at the message level, so this method is
	// 'unsafe' if called directly.
	inline PROTOBUF_NDEBUG_INLINE static void InternalSwap(
	InlinedStringField* lhs, Arena* lhs_arena, bool lhs_arena_dtor_registered,
	MessageLite* lhs_msg, //
	InlinedStringField* rhs, Arena* rhs_arena, bool rhs_arena_dtor_registered,
	MessageLite* rhs_msg);

	// Frees storage (if not on an arena).
	PROTOBUF_NDEBUG_INLINE void Destroy(const std::string* default_value,
	Arena* arena) {
	if (arena == nullptr) {
	DestroyNoArena(default_value);
	}
	}
	PROTOBUF_NDEBUG_INLINE void DestroyNoArena(const std::string* default_value);

	// Clears content, but keeps allocated std::string, to avoid the overhead of
	// heap operations. After this returns, the content (as seen by the user) will
	// always be the empty std::string.
	PROTOBUF_NDEBUG_INLINE void ClearToEmpty() { ClearNonDefaultToEmpty(); }
	PROTOBUF_NDEBUG_INLINE void ClearNonDefaultToEmpty() {
	get_mutable()->clear();
	}

	// Clears content, but keeps allocated std::string if arena != nullptr, to
	// avoid the overhead of heap operations. After this returns, the content (as
	// seen by the user) will always be equal to \|default_value\|.
	void ClearToDefault(const LazyString& default_value, Arena* arena,
	bool donated);

	// Generated code / reflection only! Returns a mutable pointer to the string.
	PROTOBUF_NDEBUG_INLINE std::string* UnsafeMutablePointer();

	// InlinedStringField doesn't have things like the `default_value` pointer in
	// ArenaStringPtr.
	static constexpr bool IsDefault() { return false; }
	static constexpr bool IsDefault(const std::string*) { return false; }

	private:
	void Destruct() { get_mutable()->~basic_string(); }

	PROTOBUF_NDEBUG_INLINE std::string* get_mutable();
	PROTOBUF_NDEBUG_INLINE const std::string* get_const() const;

	alignas(std::string) char value_[sizeof(std::string)];

	std::string* MutableSlow(::google::protobuf::Arena* arena, bool donated,
	uint32_t* donating_states, uint32_t mask,
	MessageLite* msg);


	// When constructed in an Arena, we want our destructor to be skipped.
	friend class ::google::protobuf::Arena;
	typedef void InternalArenaConstructable_;
	typedef void DestructorSkippable_;
	};

	inline std::string* InlinedStringField::get_mutable() {
	return reinterpret_cast<std::string*>(&value_);
	}

	inline const std::string* InlinedStringField::get_const() const {
	return reinterpret_cast<const std::string*>(&value_);
	}

	inline InlinedStringField::InlinedStringField(
	const std::string& default_value) {
	new (get_mutable()) std::string(default_value);
	}


	inline InlinedStringField::InlinedStringField(Arena* /arena/) { Init(); }

	inline const std::string& InlinedStringField::GetNoArena() const {
	return *get_const();
	}

	inline void InlinedStringField::SetAllocatedNoArena(
	const std::string* /default_value/, std::string* value) {
	if (value == nullptr) {
	// Currently, inlined string field can't have non empty default.
	get_mutable()->clear();
	} else {
	get_mutable()->assign(std::move(*value));
	delete value;
	}
	}

	inline void InlinedStringField::DestroyNoArena(const std::string*) {
	// This is invoked from the generated message's ArenaDtor, which is used to
	// clean up objects not allocated on the Arena.
	this->~InlinedStringField();
	}

	inline void InlinedStringField::SetNoArena(StringPiece value) {
	get_mutable()->assign(value.data(), value.length());
	}

	inline void InlinedStringField::SetNoArena(std::string&& value) {
	get_mutable()->assign(std::move(value));
	}

	// Caller should make sure rhs_arena allocated rhs, and lhs_arena allocated lhs.
	inline PROTOBUF_NDEBUG_INLINE void InlinedStringField::InternalSwap(
	InlinedStringField* lhs, Arena* lhs_arena, bool lhs_arena_dtor_registered,
	MessageLite* lhs_msg, //
	InlinedStringField* rhs, Arena* rhs_arena, bool rhs_arena_dtor_registered,
	MessageLite* rhs_msg) {
	#if GOOGLE_PROTOBUF_INTERNAL_DONATE_STEAL_INLINE
	lhs->get_mutable()->swap(*rhs->get_mutable());
	if (!lhs_arena_dtor_registered && rhs_arena_dtor_registered) {
	lhs_msg->OnDemandRegisterArenaDtor(lhs_arena);
	} else if (lhs_arena_dtor_registered && !rhs_arena_dtor_registered) {
	rhs_msg->OnDemandRegisterArenaDtor(rhs_arena);
	}
	#else
	(void)lhs_arena;
	(void)rhs_arena;
	(void)lhs_arena_dtor_registered;
	(void)rhs_arena_dtor_registered;
	(void)lhs_msg;
	(void)rhs_msg;
	lhs->get_mutable()->swap(*rhs->get_mutable());
	#endif
	}

	inline void InlinedStringField::Set(ConstStringParam value, Arena* arena,
	bool donated, uint32_t* /donating_states/,
	uint32_t /mask/, MessageLite* /msg/) {
	(void)arena;
	(void)donated;
	SetNoArena(value);
	}

	inline void InlinedStringField::Set(const char* str, ::google::protobuf::Arena* arena,
	bool donated, uint32_t* donating_states,
	uint32_t mask, MessageLite* msg) {
	Set(ConstStringParam(str), arena, donated, donating_states, mask, msg);
	}

	inline void InlinedStringField::Set(const char* str, size_t size,
	::google::protobuf::Arena* arena, bool donated,
	uint32_t* donating_states, uint32_t mask,
	MessageLite* msg) {
	Set(ConstStringParam{str, size}, arena, donated, donating_states, mask, msg);
	}

	inline void InlinedStringField::SetBytes(ConstStringParam value, Arena* arena,
	bool donated,
	uint32_t* donating_states,
	uint32_t mask, MessageLite* msg) {
	Set(value, arena, donated, donating_states, mask, msg);
	}

	inline void InlinedStringField::SetBytes(std::string&& value, Arena* arena,
	bool donated,
	uint32_t* donating_states,
	uint32_t mask, MessageLite* msg) {
	Set(std::move(value), arena, donated, donating_states, mask, msg);
	}

	inline void InlinedStringField::SetBytes(const char* str,
	::google::protobuf::Arena* arena, bool donated,
	uint32_t* donating_states,
	uint32_t mask, MessageLite* msg) {
	Set(str, arena, donated, donating_states, mask, msg);
	}

	inline void InlinedStringField::SetBytes(const void* p, size_t size,
	::google::protobuf::Arena* arena, bool donated,
	uint32_t* donating_states,
	uint32_t mask, MessageLite* msg) {
	Set(static_cast<const char*>(p), size, arena, donated, donating_states, mask,
	msg);
	}

	template <typename RefWrappedType>
	inline void InlinedStringField::Set(
	std::reference_wrapper<RefWrappedType> const_string_ref,
	::google::protobuf::Arena* arena, bool donated, uint32_t* donating_states,
	uint32_t mask, MessageLite* msg) {
	Set(const_string_ref.get(), arena, donated, donating_states, mask, msg);
	}

	template <typename RefWrappedType>
	inline void InlinedStringField::SetBytes(
	std::reference_wrapper<RefWrappedType> const_string_ref,
	::google::protobuf::Arena* arena, bool donated, uint32_t* donating_states,
	uint32_t mask, MessageLite* msg) {
	Set(const_string_ref.get(), arena, donated, donating_states, mask, msg);
	}

	inline std::string* InlinedStringField::UnsafeMutablePointer() {
	return get_mutable();
	}

	inline std::string* InlinedStringField::Mutable(std::nullptr_t) {
	return get_mutable();
	}

	inline std::string* InlinedStringField::MutableNoCopy(std::nullptr_t) {
	return get_mutable();
	}

	} // namespace internal
	} // namespace protobuf
	} // namespace google

	#include <google/protobuf/port_undef.inc>

	#endif // GOOGLE_PROTOBUF_INLINED_STRING_FIELD_H__