Struct RawName 

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

A newtype which indicates that the contained InternalName may not yet be fully-qualified.

You can convert it to a fully-qualified InternalName using .qualify_with(), .qualify_with_name(), or .conditionally_qualify_with().

Implementations

impl RawName

pub fn new(id: Id, loc: Option<Loc>) -> Self

Create a new RawName from the given Id

pub fn new_from_unreserved(id: UnreservedId, loc: Option<Loc>) -> Self

Create a new RawName from the given UnreservedId

pub fn from_name(name: InternalName) -> Self

Create a new RawName from the given InternalName.

Note that if name includes explicit namespaces, the result will be a RawName that also includes those explicit namespaces, as if that fully-qualified name appeared directly in the (JSON or Cedar) schema format. If name does not include explicit namespaces, the result will be a RawName that also does not include explicit namespaces, which may or may not translate back to the original input name, due to namespace-qualification rules.

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

Create a new RawName by parsing the provided string, which should contain an unqualified InternalName (no explicit namespaces)

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

Create a new RawName by parsing the provided string, which should contain an InternalName in normalized form.

(See the crate::FromNormalizedStr trait.)

pub fn is_unqualified(&self) -> bool

Is this RawName unqualified, that is, written without any explicit namespaces. (This method returning true does not imply that the RawName will eventually resolve to an unqualified name.)

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

Get the source location of this RawName

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

Convert this RawName to an InternalName by adding the given ns as its prefix, or by no-op if ns is None.

Note that if the RawName already had a non-empty explicit namespace, no additional prefixing will be done, even if ns is Some.

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

Convert this RawName to an InternalName by adding the given ns as its prefix, or by no-op if ns is None.

Note that if the RawName already had a non-empty explicit namespace, no additional prefixing will be done, even if ns is Some.

pub fn conditionally_qualify_with( self, ns: Option<&InternalName>, reference_type: ReferenceType, ) -> ConditionalName

Convert this RawName to a ConditionalName. This method is appropriate for when we encounter this RawName as a type reference while the current/active namespace is ns (or None if the current/active namespace is the empty namespace).

This RawName will resolve as follows:

• If the RawName already has a non-empty explicit namespace, there is no ambiguity, and it will resolve always and only to itself
• Otherwise (if the RawName does not have an explicit namespace already), then it resolves to the following in priority order:
  1. The fully-qualified name resulting from prefixing ns to this RawName, if that fully-qualified name is declared in the schema (in any schema fragment)
  2. Itself in the empty namespace, if that name is declared in the schema (in any schema fragment)

Note that if the RawName is the name of a primitive or extension type (without explicit __cedar), it will resolve via (2) above, because the primitive/extension type names will be added as defined common types in the empty namespace (aliasing to the real __cedar definitions), assuming the user didn’t themselves define those names in the empty namespace.

Trait Implementations

impl Clone for RawName

fn clone(&self) -> RawName

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RawName

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RawName

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for RawName

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

Formats the value using the given formatter.

impl From<Path> for RawName

fn from(p: Path) -> Self

Converts to this type from the input type.

impl FromStr for RawName

type Err = <InternalName as FromStr>::Err

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 RawName

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 RawName

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

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

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

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for RawName

impl StructuralPartialEq for RawName