Struct MessageField 

pub struct MessageField<T>
where
    T: Default,
{ /* private fields */ }

A wrapper for optional message fields that provides transparent access to a default instance when the field is not set.

This type is used for singular message fields in generated code. It avoids the ergonomic pain of Option<Box<M>> while still being heap-allocated only when set (no allocation for unset fields).

Access patterns

// Reading through an unset field gives the default:
let msg = Outer::default();
assert_eq!(msg.inner.name, "");  // No unwrap needed, derefs to default

// Check if set:
if msg.inner.is_set() { ... }

// Set a value:
msg.inner = MessageField::some(Inner { name: "hello".into(), ..Default::default() });

// Clear:
msg.inner = MessageField::none();

Implementations

impl<T> MessageField<T>

where T: Default,

pub const fn none() -> MessageField<T>

Create a MessageField with no value set.

pub fn some(value: T) -> MessageField<T>

Create a MessageField with a value.

pub fn from_box(value: Box<T>) -> MessageField<T>

Create a MessageField from a boxed value.

pub fn is_set(&self) -> bool

Returns true if the field has a value set.

pub fn is_unset(&self) -> bool

Returns true if the field has no value set.

pub fn as_option(&self) -> Option<&T>

Get a reference to the inner value, or None if unset.

pub fn as_option_mut(&mut self) -> Option<&mut T>

Get a mutable reference to the inner value, or None if unset.

pub fn take(&mut self) -> Option<T>

Take the inner value, leaving the field unset.

pub fn get_or_insert_default(&mut self) -> &mut T

Get a mutable reference to the value, initializing to the default if unset.

pub fn modify<F>(&mut self, f: F)

where F: FnOnce(&mut T),

Call f with a mutable reference to the inner value, initializing to the default if the field is currently unset.

This is the ergonomic write counterpart to the transparent read provided by Deref. Instead of calling get_or_insert_default once per assignment:

msg.address.get_or_insert_default().street = "123 Main St".into();
msg.address.get_or_insert_default().city   = "Springfield".into();

use modify to initialize the field once and set all sub-fields in the closure:

msg.address.modify(|a| {
    a.street = "123 Main St".into();
    a.city   = "Springfield".into();
});

pub fn into_option(self) -> Option<T>

Consume the field, returning Some(T) if set or None if unset.

This unboxes the inner value. For in-place extraction that leaves the field unset without consuming the enclosing struct, see take.

pub fn ok_or<E>(self, err: E) -> Result<T, E>

Consume the field, returning Ok(T) if set or Err(err) if unset.

Mirrors Option::ok_or. Useful for enforcing presence of semantically-required fields that the proto schema leaves optional:

let cmd = request.normalized_command.ok_or(Error::MissingCommand)?;

pub fn ok_or_else<E, F>(self, err: F) -> Result<T, E>

where F: FnOnce() -> E,

Consume the field, returning Ok(T) if set or Err(err()) if unset.

Mirrors Option::ok_or_else. The closure is only called if the field is unset, so use this over ok_or when constructing the error is non-trivial:

let cmd = request.normalized_command.ok_or_else(|| {
    ConnectError::invalid_argument("missing normalized_command in request")
})?;

Trait Implementations

impl<T> Clone for MessageField<T>

where T: Default + Clone,

fn clone(&self) -> MessageField<T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T> Debug for MessageField<T>

where T: Default + Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<T> Default for MessageField<T>

where T: Default,

fn default() -> MessageField<T>

Returns the “default value” for a type.

impl<T> Deref for MessageField<T>

where T: DefaultInstance,

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

impl<T> From<Option<T>> for MessageField<T>

where T: Default,

fn from(opt: Option<T>) -> MessageField<T>

Converts to this type from the input type.

impl<T> From<T> for MessageField<T>

where T: Default,

fn from(value: T) -> MessageField<T>

Converts to this type from the input type.

impl<T> PartialEq for MessageField<T>

where T: DefaultInstance + PartialEq,

fn eq(&self, other: &MessageField<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> Eq for MessageField<T>

where T: DefaultInstance + Eq + PartialEq,