Struct swim_structure::item::Text

#[repr(C)]
pub struct Text<'a> { /* fields omitted */ }

Value variant representing a Unicode string.

Examples

Create a Text value from a primitive str:

let value = Text::from_str("Hello");

Get a reference to the primitive str owned by a Text value:

let value = Text::from_str("Hello, world!");
let primitive = value.as_str();

Concatenate a Text value with another str using the + operator:

let value = Text::from_str("Hello");
let message = value + " " + "world";

Methods

impl<'a> Text<'a>

pub fn try_hold_str(
    hold: &dyn Hold<'a>,
    data: &str
) -> Result<Text<'a>, HoldError>

pub fn hold_str(hold: &dyn Hold<'a>, data: &str) -> Text<'a>

pub fn from_str(data: &str) -> Text<'a>

pub fn is_empty(&self) -> bool

pub fn len(&self) -> usize

pub unsafe fn set_len(&mut self, new_len: usize)

pub fn cap(&self) -> usize

pub fn as_value(&self) -> &Value<'a>

Upcasts this Text reference to a Value reference.

pub fn as_mut_value(&mut self) -> &mut Value<'a>

Upcasts this Text reference to a mutable Value reference.

pub fn into_value(self) -> Value<'a>

Upcasts this Text to a Value.

pub fn into_item(self) -> Item<'a>

Upcasts this Text to an Item.

pub fn as_ptr(&self) -> *const u8

pub fn as_mut_ptr(&mut self) -> *mut u8

pub fn as_slice(&self) -> &[u8]

pub fn as_str(&self) -> &str

pub fn as_mut_str(&mut self) -> &mut str

pub fn try_reserve(&mut self, ext: usize) -> Result<(), HoldError>

pub fn reserve(&mut self, ext: usize)

pub fn try_reserve_exact(&mut self, ext: usize) -> Result<(), HoldError>

pub fn reserve_exact(&mut self, ext: usize)

pub fn try_reserve_in_place(&mut self, ext: usize) -> Result<(), HoldError>

pub fn try_reserve_in_place_exact(
    &mut self,
    ext: usize
) -> Result<(), HoldError>

pub fn try_push(&mut self, c: char) -> Result<(), HoldError>

pub fn push(&mut self, c: char)

pub fn try_push_str(&mut self, s: &str) -> Result<(), HoldError>

pub fn push_str(&mut self, s: &str)

pub fn try_insert(&mut self, index: usize, c: char) -> Result<(), HoldError>

pub fn insert(&mut self, index: usize, c: char)

pub fn try_insert_str(&mut self, index: usize, s: &str) -> Result<(), HoldError>

pub fn insert_str(&mut self, index: usize, s: &str)

pub unsafe fn try_insert_slice(
    &mut self,
    index: usize,
    slice: &[u8]
) -> Result<(), HoldError>

pub unsafe fn insert_slice(&mut self, index: usize, slice: &[u8])

pub fn pop(&mut self) -> Option<char>

pub fn remove(&mut self, index: usize) -> char

pub fn clear(&mut self)

Trait Implementations

impl<'a> PartialEq<Text<'a>> for Text<'a>

fn eq(&self, that: &Text<'a>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, that: &Text<'a>) -> bool

This method tests for !=.

impl<'a> Eq for Text<'a>

impl<'a> Ord for Text<'a>

fn cmp(&self, other: &Text<'a>) -> Ordering

This method returns an Ordering between self and other.

default fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

default fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

default fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

impl<'a> PartialOrd<Text<'a>> for Text<'a>

fn partial_cmp(&self, that: &Text<'a>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, that: &Text<'a>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, that: &Text<'a>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn ge(&self, that: &Text<'a>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

fn gt(&self, that: &Text<'a>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

impl<'a> Deref for Text<'a>

type Target = str

The resulting type after dereferencing.

fn deref(&self) -> &str

Dereferences the value.

impl<'a> From<Text<'a>> for Item<'a>

fn from(text: Text<'a>) -> Item<'a>

Performs the conversion.

impl<'a> From<Text<'a>> for Value<'a>

fn from(text: Text<'a>) -> Value<'a>

Performs the conversion.

impl<'a> Display for Text<'a>

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<'a> Debug for Text<'a>

fn fmt(&self, _f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<'a, 'b> Add<&'b str> for Text<'a>

type Output = Text<'a>

The resulting type after applying the + operator.

fn add(self, rhs: &'b str) -> Text<'a>

Performs the + operation.

impl<'a, 'b> AddAssign<&'b str> for Text<'a>

fn add_assign(&mut self, rhs: &'b str)

Performs the += operation.

impl<'a> DerefMut for Text<'a>

fn deref_mut(&mut self) -> &mut str

Mutably dereferences the value.

impl<'a> Drop for Text<'a>

fn drop(&mut self)

Executes the destructor for this type.

impl<'a> Index<Range<usize>> for Text<'a>

type Output = str

The returned type after indexing.

fn index(&self, index: Range<usize>) -> &str

Performs the indexing (container[index]) operation.

impl<'a> Index<RangeFrom<usize>> for Text<'a>

type Output = str

The returned type after indexing.

fn index(&self, index: RangeFrom<usize>) -> &str

Performs the indexing (container[index]) operation.

impl<'a> Index<RangeFull> for Text<'a>

type Output = str

The returned type after indexing.

fn index(&self, index: RangeFull) -> &str

Performs the indexing (container[index]) operation.

impl<'a> Index<RangeInclusive<usize>> for Text<'a>

type Output = str

The returned type after indexing.

fn index(&self, index: RangeInclusive<usize>) -> &str

Performs the indexing (container[index]) operation.

impl<'a> Index<RangeTo<usize>> for Text<'a>

type Output = str

The returned type after indexing.

fn index(&self, index: RangeTo<usize>) -> &str

Performs the indexing (container[index]) operation.

impl<'a> Index<RangeToInclusive<usize>> for Text<'a>

type Output = str

The returned type after indexing.

fn index(&self, index: RangeToInclusive<usize>) -> &str

Performs the indexing (container[index]) operation.

impl<'a> IndexMut<Range<usize>> for Text<'a>

fn index_mut(&mut self, index: Range<usize>) -> &mut str

Performs the mutable indexing (container[index]) operation.

impl<'a> IndexMut<RangeFrom<usize>> for Text<'a>

fn index_mut(&mut self, index: RangeFrom<usize>) -> &mut str

Performs the mutable indexing (container[index]) operation.

impl<'a> IndexMut<RangeFull> for Text<'a>

fn index_mut(&mut self, index: RangeFull) -> &mut str

Performs the mutable indexing (container[index]) operation.

impl<'a> IndexMut<RangeInclusive<usize>> for Text<'a>

fn index_mut(&mut self, index: RangeInclusive<usize>) -> &mut str

Performs the mutable indexing (container[index]) operation.

impl<'a> IndexMut<RangeTo<usize>> for Text<'a>

fn index_mut(&mut self, index: RangeTo<usize>) -> &mut str

Performs the mutable indexing (container[index]) operation.

impl<'a> IndexMut<RangeToInclusive<usize>> for Text<'a>

fn index_mut(&mut self, index: RangeToInclusive<usize>) -> &mut str

Performs the mutable indexing (container[index]) operation.

impl<'a> Hash for Text<'a>

fn hash<H: Hasher>(&self, hasher: &mut H)

Feeds this value into the given [Hasher].

default fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl<'a> Clone for Text<'a>

fn clone(&self) -> Text<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> AsMut<Value<'a>> for Text<'a>

fn as_mut(&mut self) -> &mut Value<'a>

Performs the conversion.

impl<'a> AsMut<str> for Text<'a>

fn as_mut(&mut self) -> &mut str

Performs the conversion.

impl<'a> AsRef<Value<'a>> for Text<'a>

fn as_ref(&self) -> &Value<'a>

Performs the conversion.

impl<'a> AsRef<str> for Text<'a>

fn as_ref(&self) -> &str

Performs the conversion.

impl<'a> AsRef<[u8]> for Text<'a>

fn as_ref(&self) -> &[u8]

Performs the conversion.

impl<'a> Holder<'a> for Text<'a>

fn holder(&self) -> &'a dyn Hold<'a>

Returns the Hold that allocated this object.

impl<'a, 'b> Stow<'b, Text<'b>> for Text<'a>

unsafe fn stow(
    src: *mut Text<'a>,
    dst: *mut Text<'b>,
    hold: &dyn Hold<'b>
) -> Result<(), HoldError>

Moves the value at the src pointer to the dst pointer, recursively moving all child values into the hold. If a child stow operation fails, then any already completed child stow operations get reverted by calling unstow on the child.

unsafe fn unstow(_src: *mut Text<'a>, _dst: *mut Text<'b>)

Reverts the most recent stow operation by moving the value at the dst pointer back to the src pointer from whence it came. The memory at the src address will be in the same state the stow operation left it in.

impl<'a> TryClone for Text<'a>

fn try_clone(&self) -> Result<Text<'a>, HoldError>

Returns a clone of self; returns an error if the clone fails.

impl<'a, 'b> CloneIntoHold<'a, Text<'a>> for Text<'b>

fn try_clone_into_hold(
    &self,
    hold: &dyn Hold<'a>
) -> Result<Text<'a>, HoldError>

Returns a clone of self allocated in hold; returns an error if the clone fails.

default fn clone_into_hold(&self, hold: &dyn Hold<'a>) -> T

Returns a clone of self allocated in hold.