struct ArenaStringPtr

Default constructor, leaves current instance uninitialized (does nothing)

Constexpr constructor, initializes to a constexpr, empty string value.

Arena enabled constructor for strings without a default value.

Initializes this instance to a constexpr, empty string value, unless debug

hardening is enabled, in which case this instance will hold a forced copy.

Arena enabled constructor for strings with a non-empty default value.

Initializes this instance to a constexpr, empty string value, unless debug

hardening is enabled, in which case this instance will be forced to hold a

forced copy of the value in `default_value`.

Arena enabled copy constructor for strings without a default value.

This instance will be initialized with a copy of the value in `rhs`.

If `rhs` holds a default (empty) value, then this instance will also be

initialized with the default empty value, unless debug hardening is

enabled, in which case this instance will be forced to hold a copy of

an empty default value.

Arena enabled copy constructor for strings with a non-empty default value.

This instance will be initialized with a copy of the value in `rhs`.

If `rhs` holds a default (empty) value, then this instance will also be

initialized with the default empty value, unless debug hardening is

enabled, in which case this instance will be forced to hold forced copy

of the value in `default_value`.

Called from generated code / reflection runtime only. Resets value to point

to a default string pointer, with the semantics that this ArenaStringPtr

does not own the pointed-to memory. Disregards initial value of ptr_ (so

this is the *ONLY* safe method to call after construction or when

reinitializing after becoming the active field in a oneof union).

Similar to `InitDefault` except that it allows the default value to be

initialized to an externally owned string. This method is called from

parsing code. `str` must not be null and outlive this instance.

Called from generated code / reflection runtime only. Resets the value of

this instances to the heap allocated value in `str`. `str` must not be

null. Invokes `arena->Own(str)` to transfer ownership into the arena if

`arena` is not null, else, `str` will be owned by ArenaStringPtr. This

function should only be used to initialize a ArenaStringPtr or on an

instance known to not carry any heap allocated value.

Returns a mutable std::string reference.

The version accepting a `LazyString` value is used in the generated code to

initialize mutable copies for fields with a non-empty default where the

default value is lazily initialized.

Gets a mutable pointer with unspecified contents.

This function is identical to Mutable(), except it is optimized for the

case where the caller is not interested in the current contents. For

example, if the current field is not mutable, it will re-initialize the

value with an empty string rather than a (non-empty) default value.

Likewise, if the current value is a fixed size arena string with contents,

it will be initialized into an empty mutable arena string.

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 the default state.

Used to implement release_

<field

>() methods on generated classes.

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.

Frees storage (if not on an arena).

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. Assumes that |default_value| is an empty

std::string.

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|.

Basic accessors.

Returns a pointer to the stored contents for this instance.

This method is for internal debugging and tracking purposes only.

Internal setter used only at parse time to directly set a donated string

value.

Returns true if this instances holds an immutable default value.

Clears content, assuming that the current value is not the empty

string default.

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.

Generated code only! An optimization, in certain cases the generated

code is certain we can obtain a std::string with no default checks and

tag tests.