Struct QualifiedName

pub struct QualifiedName(/* private fields */);

A qualified name, consisting of a sequence of name segments.

A qualified name is a sequence of segments that unambiguously names an element in a set, or a family of sets, or a family of family of sets, and so on. For example, a qualified name with three segments can be constructed as

let name: QualifiedName = ["foo", "bar", "baz"].map(NameSegment::from).into();
assert_eq!(name.to_string(), "foo.bar.baz");

Data structure

At this time, a qualified name is stored simply as a vector of name segments. Various optimizations could be considered, such as an Rc<[NameSegment]> or, since qualified names tend to have only a few segments, a SmallVec<[NameSegment; n]> for some choice of n. These will be considered premature optimizations until there is good evidence in favor of them.

Serialization

To simplify their use in JavaScript, qualified name are serialized as flat strings with segments separated by periods. Human-readable names are quoted with backticks regardless of whether they contain whitespace, which makes parsing easier. Note that the display format is different from the serialization format.

Implementations

impl QualifiedName

pub fn single(segment: NameSegment) -> Self

Constructs a qualified name with a single segment.

pub fn segments(&self) -> impl Iterator<Item = &NameSegment>

Iterates over the segments of the qualified name.

pub fn only(&self) -> Option<NameSegment>

Gets the segment from a qualified name with only one segment.

pub fn serialize_string(&self) -> String

Serializes the qualified name into a string.

pub fn deserialize_str(input: &str) -> Result<Self, String>

Deserializes a qualified name from a string.

Trait Implementations

impl Clone for QualifiedName

fn clone(&self) -> QualifiedName

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for QualifiedName

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for QualifiedName

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for QualifiedName

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

Formats the value using the given formatter.

impl From<&str> for QualifiedName

fn from(name: &str) -> Self

Converts to this type from the input type.

impl<const N: usize> From<[&str; N]> for QualifiedName

fn from(segments: [&str; N]) -> Self

Converts to this type from the input type.

impl<const N: usize> From<[NameSegment; N]> for QualifiedName

fn from(segments: [NameSegment; N]) -> Self

Converts to this type from the input type.

impl<const N: usize> From<[Uuid; N]> for QualifiedName

fn from(segments: [Uuid; N]) -> Self

Converts to this type from the input type.

impl From<QualifiedName> for JsValue

where QualifiedName: Serialize,

fn from(value: QualifiedName) -> Self

Converts to this type from the input type.

impl From<QualifiedName> for ModalMor

fn from(value: QualifiedName) -> Self

Converts to this type from the input type.

impl From<QualifiedName> for ModalOb

fn from(value: QualifiedName) -> Self

Converts to this type from the input type.

impl From<QualifiedName> for ModalOp

fn from(value: QualifiedName) -> Self

Converts to this type from the input type.

impl From<QualifiedName> for TabMor

fn from(value: QualifiedName) -> Self

Converts to this type from the input type.

impl From<QualifiedName> for TabEdge

fn from(value: QualifiedName) -> Self

Converts to this type from the input type.

impl From<QualifiedName> for TabMorType

fn from(value: QualifiedName) -> Self

Converts to this type from the input type.

impl From<QualifiedName> for TabOb

fn from(value: QualifiedName) -> Self

Converts to this type from the input type.

impl From<QualifiedName> for TabObType

fn from(value: QualifiedName) -> Self

Converts to this type from the input type.

impl From<Ustr> for QualifiedName

fn from(name: Ustr) -> Self

Converts to this type from the input type.

impl From<Uuid> for QualifiedName

fn from(id: Uuid) -> Self

Converts to this type from the input type.

impl From<Vec<NameSegment>> for QualifiedName

fn from(value: Vec<NameSegment>) -> Self

Converts to this type from the input type.

impl FromWasmAbi for QualifiedName

where Self: DeserializeOwned,

type Abi = <JsType as FromWasmAbi>::Abi

The Wasm ABI type that this converts from when coming back out from the ABI boundary.

unsafe fn from_abi(js: Self::Abi) -> Self

Recover a Self from Self::Abi.

impl Hash for QualifiedName

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 IntoWasmAbi for QualifiedName

where QualifiedName: Serialize,

type Abi = <JsType as IntoWasmAbi>::Abi

The Wasm ABI type that this converts into when crossing the ABI boundary.

fn into_abi(self) -> Self::Abi

Convert self into Self::Abi so that it can be sent across the wasm ABI boundary.

impl OptionFromWasmAbi for QualifiedName

where Self: DeserializeOwned,

fn is_none(js: &Self::Abi) -> bool

Tests whether the argument is a “none” instance. If so it will be deserialized as None, and otherwise it will be passed to FromWasmAbi.

impl OptionIntoWasmAbi for QualifiedName

where QualifiedName: Serialize,

fn none() -> Self::Abi

Returns an ABI instance indicating “none”, which JS will interpret as the None branch of this option.

impl Ord for QualifiedName

fn cmp(&self, other: &QualifiedName) -> 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 PartialEq for QualifiedName

fn eq(&self, other: &QualifiedName) -> 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 PartialOrd for QualifiedName

fn partial_cmp(&self, other: &QualifiedName) -> 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 RefFromWasmAbi for QualifiedName

where Self: DeserializeOwned,

type Abi = <JsType as RefFromWasmAbi>::Abi

The Wasm ABI type references to Self are recovered from.

type Anchor = SelfOwner<QualifiedName>

The type that holds the reference to Self for the duration of the invocation of the function that has an &Self parameter. This is required to ensure that the lifetimes don’t persist beyond one function call, and so that they remain anonymous.

unsafe fn ref_from_abi(js: Self::Abi) -> Self::Anchor

Recover a Self::Anchor from Self::Abi.

impl Serialize for QualifiedName

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

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Tsify for QualifiedName

const DECL: &'static str = "/**\n * A qualified name, consisting of a sequence of [name segments](NameSegment).\\n\\nA qualified name is a sequence of segments that unambiguously names an element\\nin a set, or a family of sets, or a family of family of sets, and so on. For\\nexample, a qualified name with three segments can be constructed as\\n\\n```\\n# use catlog::zero::qualified::*;\\nlet name: QualifiedName = [\\\"foo\\\", \\\"bar\\\", \\\"baz\\\"].map(NameSegment::from).into();\\nassert_eq!(name.to_string(), \\\"foo.bar.baz\\\");\\n```\\n\\n# Data structure\\n\\nAt this time, a qualified name is stored simply as a vector of name segments.\\nVarious optimizations could be considered, such as an `Rc<[NameSegment]>` or,\\nsince qualified names tend to have only a few segments, a\\n`SmallVec<[NameSegment; n]>` for some choice of `n`. These will be considered\\npremature optimizations until there is good evidence in favor of them.\\n\\n# Serialization\\n\\nTo simplify their use in JavaScript, qualified name are serialized as flat\\nstrings with segments separated by periods. Human-readable names are quoted with\\nbackticks regardless of whether they contain whitespace, which makes parsing\\neasier. Note that the [display](Display) format is different from the\\nserialization format.\\n \n */\nexport type QualifiedName = string;"

const SERIALIZATION_CONFIG: SerializationConfig

type JsType = JsType

fn into_js(&self) -> Result<Self::JsType, Error>

where Self: Serialize,

fn from_js<T>(js: T) -> Result<Self, Error>

where T: Into<JsValue>, Self: DeserializeOwned,

impl VectorFromWasmAbi for QualifiedName

where Self: DeserializeOwned,

type Abi = <JsType as VectorFromWasmAbi>::Abi

unsafe fn vector_from_abi(js: Self::Abi) -> Box<[Self]>

impl VectorIntoWasmAbi for QualifiedName

where QualifiedName: Serialize,

type Abi = <JsType as VectorIntoWasmAbi>::Abi

fn vector_into_abi(vector: Box<[Self]>) -> Self::Abi

impl WasmDescribe for QualifiedName

fn describe()

impl WasmDescribeVector for QualifiedName

fn describe_vector()

impl Eq for QualifiedName

impl StructuralPartialEq for QualifiedName