Struct ConditionalName 

pub struct ConditionalName { /* private fields */ }

A name which may refer to many possible different fully-qualified names, depending on which of them are declared (in any schema fragment)

Caution using == on these: ConditionalNames are only equal if the have the same raw (source) and the same list of possible resolution targets (in the same order), which in practice means they must be in the same current/active namespace. In particular:

• two ConditionalNames which end up resolving to the same fully-qualified name may nonetheless not be == in their ConditionalName forms; and
• two ConditionalNames which are written the same way in the original schema may nonetheless not be == in their ConditionalName forms

This type has only one (trivial) public constructor; it is normally constructed using RawName::conditionally_qualify_with().

Implementations

impl ConditionalName

pub fn unconditional(name: InternalName, reference_type: ReferenceType) -> Self

Create a ConditionalName which unconditionally resolves to the given fully-qualified InternalName.

pub fn raw(&self) -> &RawName

Get the (not-yet-necessarily-fully-qualified) RawName which was encountered in the source, for the purposes of error messages

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

Get the source location of this ConditionalName

pub fn resolve( self, all_defs: &AllDefs, ) -> Result<InternalName, TypeNotDefinedError>

Resolve the ConditionalName into a fully-qualified InternalName, given that all_defs includes all fully-qualified InternalNames defined in all schema fragments.

Note that this returns InternalName (as opposed to Name), because type references may resolve to an internal name like __cedar::String. In general, as noted on InternalName, InternalNames are valid to appear as type references, and we generally expect ConditionalNames to also represent type references.

all_defs also internally includes InternalNames, because some names containing __cedar might be internally defined/valid, even though it is not valid for end-users to define those names.

Trait Implementations

impl Clone for ConditionalName

fn clone(&self) -> ConditionalName

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ConditionalName

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

Formats the value using the given formatter.

impl Hash for ConditionalName

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 PartialEq for ConditionalName

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

ConditionalName serializes as simply the raw name that was originally encountered in the schema

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 ConditionalName

impl StructuralPartialEq for ConditionalName