Struct LimitedStr 

pub struct LimitedStr<'a, const N: usize = 1024>(/* private fields */);

Wrapped string to fit given amount of bytes.

The Cow is used to avoid allocating a new String when the LimitedStr is created from a &str.

Plain str is not used because it can’t be properly encoded/decoded via scale codec.

Implementations

impl<'a, const N: usize> LimitedStr<'a, N>

pub const MAX_LEN: usize = N

Maximum length of the string.

pub fn from_utf8(vec: LimitedVec<u8, N>) -> Result<Self, FromUtf8Error>

Constructs a limited string from a limited vector of bytes of the same size.

pub fn try_new<S: Into<Cow<'a, str>>>(s: S) -> Result<Self, LimitedStrError>

Constructs a limited string from a string.

Checks the size of the string.

pub fn truncated<S: Into<Cow<'a, str>>>(s: S) -> Self

Constructs a limited string from a string truncating it if it’s too long.

pub const fn from_small_str(s: &'static str) -> Self

Constructs a limited string from a static string literal small enough to fit the limit.

Should be used only with static string literals. In that case it can check the string length in compile time.

Panics

Can panic in runtime if the passed string is not a static string literal and is too long.

pub fn as_str(&self) -> &str

Return string slice.

pub fn into_inner(self) -> Cow<'a, str>

Return inner value.

Trait Implementations

impl<'a, const N: usize, __AsT: ?Sized> AsRef<__AsT> for LimitedStr<'a, N>

where Cow<'a, str>: AsRef<__AsT>,

fn as_ref(&self) -> &__AsT

Converts this type into a shared reference of the (usually inferred) input type.

impl<'a, const N: usize> Clone for LimitedStr<'a, N>

fn clone(&self) -> LimitedStr<'a, N>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a, const N: usize> Debug for LimitedStr<'a, N>

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

Formats the value using the given formatter.

impl<'a, const N: usize> Decode for LimitedStr<'a, N>

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Attempt to deserialise the value from input.

fn decode_into<I>( input: &mut I, dst: &mut MaybeUninit<Self>, ) -> Result<DecodeFinished, Error>

where I: Input,

Attempt to deserialize the value from input into a pre-allocated piece of memory.

fn skip<I>(input: &mut I) -> Result<(), Error>

where I: Input,

Attempt to skip the encoded value from input.

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

impl<'a, const N: usize> Default for LimitedStr<'a, N>

fn default() -> LimitedStr<'a, N>

Returns the “default value” for a type.

impl<'a, const N: usize> Deref for LimitedStr<'a, N>

where Cow<'a, str>: Deref,

type Target = <Cow<'a, str> as Deref>::Target

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'a, const N: usize> Display for LimitedStr<'a, N>

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

Formats the value using the given formatter.

impl<'a, const N: usize> Encode for LimitedStr<'a, N>

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding.

fn encode_to<__CodecOutputEdqy: Output + ?Sized>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

Convert self to a slice and append it to the destination.

fn encode(&self) -> Vec<u8>

Convert self to an owned vector.

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

Convert self to a slice and then invoke the given closure with it.

fn encoded_size(&self) -> usize

Calculates the encoded size.

impl<'a, const N: usize> EncodeAsFields for LimitedStr<'a, N>

fn encode_as_fields_to<ScaleEncodeResolver: TypeResolver>( &self, __encode_as_type_fields: &mut dyn FieldIter<'_, ScaleEncodeResolver::TypeId>, __encode_as_type_types: &ScaleEncodeResolver, __encode_as_type_out: &mut Vec<u8>, ) -> Result<(), Error>

Given some fields describing the shape of a type, attempt to encode to that shape.

fn encode_as_fields<R>( &self, fields: &mut dyn FieldIter<'_, <R as TypeResolver>::TypeId, Item = Field<'_, <R as TypeResolver>::TypeId>>, types: &R, ) -> Result<Vec<u8>, Error>

where R: TypeResolver,

This is a helper function which internally calls EncodeAsFields::encode_as_fields_to. Prefer to implement that instead.

impl<'a, const N: usize> EncodeAsType for LimitedStr<'a, N>

fn encode_as_type_to<ScaleEncodeResolver: TypeResolver>( &self, __encode_as_type_type_id: ScaleEncodeResolver::TypeId, __encode_as_type_types: &ScaleEncodeResolver, __encode_as_type_out: &mut Vec<u8>, ) -> Result<(), Error>

Given some type_id, types, a context and some output target for the SCALE encoded bytes, attempt to SCALE encode the current value into the type given by type_id.

fn encode_as_type<R>( &self, type_id: <R as TypeResolver>::TypeId, types: &R, ) -> Result<Vec<u8>, Error>

where R: TypeResolver,

This is a helper function which internally calls EncodeAsType::encode_as_type_to. Prefer to implement that instead.

impl<'a, const N: usize> EncodeLike for LimitedStr<'a, N>

impl<'a, const N: usize> Eq for LimitedStr<'a, N>

impl From<LimitedStr<'_>> for PanicBuffer

fn from(value: LimitedStr<'_>) -> Self

Converts to this type from the input type.

impl<'a, const N: usize> From<LimitedStr<'a, N>> for Cow<'a, str>

fn from(value: LimitedStr<'a, N>) -> Self

Converts to this type from the input type.

impl<'a, const N: usize> Hash for LimitedStr<'a, N>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a, const N: usize> Ord for LimitedStr<'a, N>

fn cmp(&self, other: &LimitedStr<'a, N>) -> 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,

Restrict a value to a certain interval.

impl<'a, const N: usize> PartialEq for LimitedStr<'a, N>

fn eq(&self, other: &LimitedStr<'a, N>) -> 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<'a, const N: usize> PartialOrd for LimitedStr<'a, N>

fn partial_cmp(&self, other: &LimitedStr<'a, N>) -> Option<Ordering>

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

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl<'a, const N: usize> StructuralPartialEq for LimitedStr<'a, N>

impl<'a, const N: usize> TryFrom<&'a str> for LimitedStr<'a, N>

type Error = LimitedStrError

The type returned in the event of a conversion error.

fn try_from(value: &'a str) -> Result<Self, Self::Error>

Performs the conversion.

impl<'a, const N: usize> TryFrom<String> for LimitedStr<'a, N>

type Error = LimitedStrError

The type returned in the event of a conversion error.

fn try_from(value: String) -> Result<Self, Self::Error>

Performs the conversion.

impl<'a, const N: usize> TypeInfo for LimitedStr<'a, N>

where 'a: 'static,

type Identity = LimitedStr<'a, N>

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.