Enum AtprotoStr 

pub enum AtprotoStr<S: Bos<str> + AsRef<str> = DefaultStr> {
    Datetime(Datetime),
    Language(Language),
    Tid(Tid),
    Nsid(Nsid<S>),
    Did(Did<S>),
    Handle(Handle<S>),
    AtIdentifier(AtIdentifier<S>),
    AtUri(AtUri<S>),
    Uri(UriValue<S>),
    Cid(Cid<S>),
    RecordKey(RecordKey<Rkey<S>>),
    String(S),
}

Polymorphic AT Protocol string value

Represents any AT Protocol string type, automatically detecting and parsing into the appropriate variant. Used internally for generic value handling.

Variants are checked in order from most specific to least specific. Note that record keys are intentionally NOT parsed from bare strings as the validation is too permissive and would catch too many values.

Variants

Datetime(Datetime)

ISO 8601 datetime

Language(Language)

BCP 47 language tag

Tid(Tid)

Timestamp identifier

Nsid(Nsid<S>)

Namespaced identifier

Did(Did<S>)

Decentralized identifier

Handle(Handle<S>)

Account handle

AtIdentifier(AtIdentifier<S>)

Identifier (DID or handle)

AtUri(AtUri<S>)

AT URI

Uri(UriValue<S>)

Generic URI

Cid(Cid<S>)

Content identifier

RecordKey(RecordKey<Rkey<S>>)

Record key

String(S)

Plain string (fallback)

Implementations

impl<S: Bos<str> + AsRef<str>> AtprotoStr<S>

pub fn new(string: S) -> Self

Classify and wrap a string value into the appropriate variant.

This is fairly exhaustive and potentially slow, prefer using anything that narrows down the search field quicker.

Inspects the string content, validates against known AT Protocol types, and moves string into the matching variant via unchecked constructors (safe because we validate first).

pub fn as_str(&self) -> &str

Get the string value regardless of variant.

pub fn string_type(&self) -> LexiconStringType

Detailed string type classification.

impl<S: Bos<str> + AsRef<str>> AtprotoStr<S>

pub fn convert<B: Bos<str> + AsRef<str> + From<S>>(self) -> AtprotoStr<B>

Convert to an AtprotoStr with a different backing type.

Trait Implementations

impl<S: Bos<str> + AsRef<str>> AsRef<str> for AtprotoStr<S>

fn as_ref(&self) -> &str

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

impl<S: Clone + Bos<str> + AsRef<str>> Clone for AtprotoStr<S>

fn clone(&self) -> AtprotoStr<S>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S: Debug + Bos<str> + AsRef<str>> Debug for AtprotoStr<S>

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

Formats the value using the given formatter.

impl<'de, S> Deserialize<'de> for AtprotoStr<S>

where S: Bos<str> + AsRef<str> + Deserialize<'de>,

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<S: Eq + Bos<str> + AsRef<str>> Eq for AtprotoStr<S>

impl<S: Bos<str> + AsRef<str> + Clone + Serialize> From<AtprotoStr<S>> for String

fn from(value: AtprotoStr<S>) -> Self

Converts to this type from the input type.

impl<S> From<AtprotoStr<S>> for Data<S>

where S: AsRef<str> + Bos<str>,

fn from(t: AtprotoStr<S>) -> Self

Converts to this type from the input type.

impl<S: Hash + Bos<str> + AsRef<str>> Hash for AtprotoStr<S>

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<S: Bos<str> + AsRef<str> + IntoStatic> IntoStatic for AtprotoStr<S>

where S::Output: Bos<str> + AsRef<str>,

type Output = AtprotoStr<<S as IntoStatic>::Output>

The “owned” variant of the type. For Cow<'a, str>, this is Cow<'static, str>, for example.

fn into_static(self) -> Self::Output

Turns the value into an “owned” variant, which can then be returned, moved, etc.

impl<S: PartialEq + Bos<str> + AsRef<str>> PartialEq for AtprotoStr<S>

fn eq(&self, other: &AtprotoStr<S>) -> 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<S: Bos<str> + AsRef<str> + Serialize> Serialize for AtprotoStr<S>

fn serialize<Ser>(&self, serializer: Ser) -> Result<Ser::Ok, Ser::Error>

where Ser: Serializer,

Serialize this value into the given Serde serializer.

impl<S: Bos<str> + AsRef<str>> StructuralPartialEq for AtprotoStr<S>