Struct InternalName

pub struct InternalName { /* private fields */ }

Represents the name of an entity type, function, etc. The name may include namespaces. Clone is O(1).

This type may contain any name valid for use internally, including names with reserved __cedar components (and also names without __cedar).

Implementations

impl InternalName

pub fn new( basename: Id, path: impl IntoIterator<Item = Id>, loc: Option<Loc>, ) -> Self

A full constructor for InternalName

pub fn unqualified_name(id: Id) -> Self

Create an InternalName with no path (no namespaces).

pub fn __cedar() -> Self

Get the InternalName representing the reserved __cedar namespace

pub fn parse_unqualified_name(s: &str) -> Result<Self, ParseErrors>

Create an InternalName with no path (no namespaces). Returns an error if s is not a valid identifier.

pub fn type_in_namespace( basename: Id, namespace: InternalName, loc: Option<Loc>, ) -> InternalName

Given a type basename and a namespace (as an InternalName itself), return an InternalName representing the type’s fully qualified name

pub fn loc(&self) -> Option<&Loc>

Get the source location

pub fn basename(&self) -> &Id

Get the basename of the InternalName (ie, with namespaces stripped).

pub fn namespace_components(&self) -> impl Iterator<Item = &Id>

Get the namespace of the InternalName, as components

pub fn namespace(&self) -> String

Get the full namespace of the InternalName, as a single string.

Examples:

• foo::bar –> the namespace is "foo"
• bar –> the namespace is ""
• foo::bar::baz –> the namespace is "foo::bar"

pub fn qualify_with(&self, namespace: Option<&InternalName>) -> InternalName

Qualify the name with a namespace

If the name already has a non-empty namespace, this method does not apply any prefix and instead returns a copy of self.

If namespace is None, that represents the empty namespace, so no prefixing will be done.

If the name does not already have an explicit namespace (i.e., it’s just a single Id), this applies namespace as a prefix (if it is present).

Examples:

• A::B.qualify_with(None) is A::B
• A::B.qualify_with(Some(C)) is also A::B
• A.qualify_with(None) is A
• A.qualify_with(Some(C)) is C::A
• A.qualify_with(Some(B::C)) is B::C::A

pub fn qualify_with_name(&self, namespace: Option<&Name>) -> InternalName

Like qualify_with(), but accepts a Name as the namespace to qualify with

pub fn is_unqualified(&self) -> bool

Test if an InternalName is an Id

pub fn is_reserved(&self) -> bool

Test if an InternalName is reserved i.e., any of its components matches __cedar

Trait Implementations

impl AsRef<InternalName> for Name

fn as_ref(&self) -> &InternalName

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

impl Clone for InternalName

fn clone(&self) -> InternalName

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for InternalName

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for InternalName

Deserialize an InternalName using from_normalized_str. This deserialization implementation is used in the JSON schema format.

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for InternalName

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

Formats the value using the given formatter.

impl From<Id> for InternalName

A shortcut for InternalName::unqualified_name

fn from(value: Id) -> Self

Converts to this type from the input type.

impl From<Name> for InternalName

fn from(value: Name) -> Self

Converts to this type from the input type.

impl FromNormalizedStr for InternalName

fn describe_self() -> &'static str

Short string description of the Self type, to be used in error messages. What are we trying to parse?

fn from_normalized_str(s: &str) -> Result<Self, ParseErrors>

Create a Self by parsing a string, which is required to be normalized. That is, the input is required to roundtrip with the Display impl on Self: Self::from_normalized_str(x).to_string() == x must hold.

impl FromStr for InternalName

type Err = ParseErrors

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for InternalName

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 Ord for InternalName

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,

Restrict a value to a certain interval.

impl PartialEq for InternalName

PartialEq implementation ignores the loc.

fn eq(&self, other: &Self) -> 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 InternalName

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

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 Serialize for InternalName

Serialize an InternalName using its Display implementation This serialization implementation is used in the JSON schema format.

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

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<'a> TryFrom<&'a InternalName> for &'a Name

type Error = ReservedNameError

The type returned in the event of a conversion error.

fn try_from(value: &'a InternalName) -> Result<&'a Name, ReservedNameError>

Performs the conversion.

impl TryFrom<InternalName> for Id

Convert a InternalName to an Id The error type is the unit type because the reason the conversion fails is obvious

type Error = ()

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TryFrom<InternalName> for Name

type Error = ReservedNameError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl Eq for InternalName