Struct tstr::TStr

pub struct TStr<T>(/* private fields */);

A type-level string type, similar to a &'static str const parameter.

Examples

Accessing Fields

This example demonstrates how you can use TStr to implement a generic accessor trait.

use tstr::TStr;
use tstr::{TS, ts};

fn main() {
    let mut tup = (3, 5, 8);
     
    assert_eq!(tup.get(ts!(0)), &3);
    assert_eq!(tup.get(ts!(1)), &5);
    assert_eq!(tup.get(ts!(2)), &8);

    let old_0 = replace(&mut tup, ts!(0), 333);
    let old_1 = replace(&mut tup, ts!(1), 555);
    let old_2 = replace(&mut tup, ts!(2), 888);
     
    assert_eq!(tup.get(ts!(0)), &333);
    assert_eq!(tup.get(ts!(1)), &555);
    assert_eq!(tup.get(ts!(2)), &888);

    assert_eq!(old_0, 3);
    assert_eq!(old_1, 5);
    assert_eq!(old_2, 8);
     
}

fn replace<T, N>(this: &mut T, name: TStr<N>, replacement: T::Field) -> T::Field
where
    T: Access<TStr<N>>,
    T::Field: Clone,
{
    let ret = this.get(name).clone();
    this.set(name, replacement);
    ret
}


trait Access<N> {
    type Field;

    fn get(&self, _field_name: N) -> &Self::Field;
    fn set(&mut self, _field_name: N, val: Self::Field);
}

impl<A, B, C> Access<TS!(0)> for (A, B, C) {
    type Field = A;

    fn get(&self, _field_name: TS!(0)) -> &A {
        &self.0
    }
    fn set(&mut self, _field_name: TS!(0), val: A){
        self.0 = val;
    }
}

impl<A, B, C> Access<TS!(1)> for (A, B, C) {
    type Field = B;

    fn get(&self, _field_name: TS!(1)) -> &B {
        &self.1
    }
    fn set(&mut self, _field_name: TS!(1), val: B){
        self.1 = val;
    }
}

impl<A, B, C> Access<TS!(2)> for (A, B, C) {
    type Field = C;

    fn get(&self, _field_name: TS!(2)) -> &C {
        &self.2
    }
    fn set(&mut self, _field_name: TS!(2), val: C){
        self.2 = val;
    }
}

Implementations

impl<T> TStr<T>

pub const NEW: Self = _

Constructs the TStr.

Example

use tstr::{TS, TStr};

type FOO = TS!(foo);

let foo_1: FOO = TStr::NEW;
let foo_2 = FOO::NEW; // The same as the previous statement

impl<T> TStr<T>

where Self: StrValue,

pub const STR: &'static str = <Self as StrValue>::STR

Available on crate feature const_generics only.

The &'static str value of this TStr.

Example

use tstr::TS;

type FOO = TS!(foo);
type BAR = TS!(bar);

assert_eq!(FOO::STR, "foo");
assert_eq!(BAR::STR, "bar");

Trait Implementations

impl<T> Clone for TStr<T>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for TStr<T>

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

Formats the value using the given formatter.

impl<T> Default for TStr<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T> MakeTStr for TStr<T>

const MAKE: Self = TStr::NEW

Gets a value of this type

impl<T> Ord for TStr<T>

fn cmp(&self, _other: &Self) -> Ordering

This method returns an Ordering between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

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

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl<T> PartialEq for TStr<T>

fn eq(&self, _other: &Self) -> bool

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

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

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

impl<T> PartialOrd for TStr<T>

fn partial_cmp(&self, _other: &Self) -> Option<Ordering>

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

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

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

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

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

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

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

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

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

impl<T, U> TStrEq<TStr<U>> for TStr<T>

where T: TStrEq<U>,

Available on crate feature cmp_traits only.

const EQ: bool = T::EQ

Whether Self equals Rhs

const NE: bool = _

Whether Self is not equal to Rhs

fn tstr_eq(&self, _other: &Rhs) -> bool

Returns whether self is equal to other.

fn tstr_ne(&self, _other: &Rhs) -> bool

Returns whether self is not equal to other.

impl<T, U> TStrOrd<TStr<U>> for TStr<T>

where T: TStrOrd<U>,

Available on crate features cmp_traits and const_generics only.

const CMP: Ordering = T::CMP

The Ordering of Self relative to Rhs.

fn tstr_cmp(&self, _other: &Rhs) -> Ordering

Compares self and other for ordering.

impl<T> ToUint for TStr<T>

where T: ToUint,

const U128: u128 = T::U128

The u128 value of the type.

const USIZE: usize = _

The usize value of the type.

fn to_usize(&self) -> usize

Gets the usize value of this type

fn to_u128(&self) -> u128

Gets the u128 value of this type

impl<T> Copy for TStr<T>

impl<T> Eq for TStr<T>