Enum AtprotoStr 

pub enum AtprotoStr<'s> {
    Datetime(Datetime),
    Language(Language),
    Tid(Tid),
    Nsid(Nsid<'s>),
    Did(Did<'s>),
    Handle(Handle<'s>),
    AtIdentifier(AtIdentifier<'s>),
    AtUri(AtUri<'s>),
    Uri(Uri<'s>),
    Cid(Cid<'s>),
    RecordKey(RecordKey<Rkey<'s>>),
    String(CowStr<'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(Uri<'s>)

Generic URI

Cid(Cid<'s>)

Content identifier

RecordKey(RecordKey<Rkey<'s>>)

Record key

String(CowStr<'s>)

Plain string (fallback)

Implementations

impl<'s> AtprotoStr<'s>

pub fn new(string: &'s str) -> Self

Borrowing constructor for bare atproto string values This is fairly exhaustive and potentially slow, prefer using anything that narrows down the search field quicker.

Note: We don’t construct record keys from bare strings in this because the type is too permissive and too many things would be classified as rkeys.

Value object deserialization checks against the field names for common names (uri, cid, did, handle, createdAt, indexedAt, etc.) to improve performance of the happy path.

pub fn as_str(&self) -> &str

Get the string value regardless of variant

impl AtprotoStr<'static>

pub fn new_owned(string: impl AsRef<str>) -> AtprotoStr<'static>

Owned constructor for bare atproto string values This is fairly exhaustive and potentially slow, prefer using anything that narrows down the search field quicker.

Note: We don’t construct record keys from bare strings in this because the type is too permissive and too many things would be classified as rkeys.

Value object deserialization checks against the field names for common names (uri, cid, did, handle, createdAt, indexedAt, etc.) to improve performance of the happy path.

Trait Implementations

impl<'s> 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 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 for AtprotoStr<'s>

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

Formats the value using the given formatter.

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

where 'de: 'a,

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<AtprotoStr<'_>> for String

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

Converts to this type from the input type.

impl<'s> 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 IntoStatic for AtprotoStr<'_>

type Output = AtprotoStr<'static>

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 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 Serialize for AtprotoStr<'_>

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

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<'s> Eq for AtprotoStr<'s>

impl<'s> StructuralPartialEq for AtprotoStr<'s>