Struct TypeIdent 

pub struct TypeIdent {
    pub ns: NamespaceId,
    pub schema: SchemaId,
    pub name: Name,
    pub type_: TypeIdentType,
}

Type that is used to identify types in the schema definition.

Fields

ns: NamespaceId

Namespace the type is defined in

schema: SchemaId

Id of the schema file the type pointed to by this identifier was defined at.

This is needed to support the case when identifier are duplicated across schema files, or redefined by xs:redefine or xs:override.

name: Name

Name of the type.

type_: TypeIdentType

Type of the identifier (because pure names are not unique in XSD).

Implementations

impl TypeIdent

pub const UNKNOWN: Self

pub const U8: Self

pub const U16: Self

pub const U32: Self

pub const U64: Self

pub const U128: Self

pub const USIZE: Self

pub const I8: Self

pub const I16: Self

pub const I32: Self

pub const I64: Self

pub const I128: Self

pub const ISIZE: Self

pub const F32: Self

pub const F64: Self

pub const BOOL: Self

pub const STR: Self

pub const STRING: Self

pub const ANY_TYPE: Self

pub const BUILD_IN: &[Self]

impl TypeIdent

pub const fn new(name: Name) -> Self

Create a new TypeIdent instance with IdentType::Type and the passed name.

pub const fn type_(name: &'static str) -> Self

Create a new TypeIdent instance with IdentType::Type and the passed name.

pub const fn build_in(name: &'static str) -> Self

Create a new TypeIdent instance with IdentType::BuildIn and the passed name.

pub const fn element(name: &'static str) -> Self

Create a new TypeIdent instance with IdentType::Element and the passed name.

pub fn with_ns(self, ns: NamespaceId) -> Self

Change the NamespaceId of this type identifier.

pub fn with_schema(self, schema: SchemaId) -> Self

Change the SchemaId of this type identifier.

pub fn with_name(self, name: Name) -> Self

Change the Name of this type identifier.

pub fn with_type(self, type_: TypeIdentType) -> Self

Change the TypeIdentType of this type identifier.

pub fn matches(&self, other: &Self) -> bool

Returns true if the passed identifier matches the current one.

This ignores the values stored in ns and schema if they are set to UNKNOWN.

pub fn to_property_ident(&self) -> PropertyIdent

Convert this type identifier into a PropertyIdent by dropping the schema and type information.

pub fn is_build_in(&self) -> bool

Returns true if this is build-in type of the rust language, false otherwise.

pub fn is_fully_qualified(&self) -> bool

Returns true if this identifier is fully qualified, false otherwise.

The identifier is fully qualified, if neither the ns, nor the schema is set to UNKNOWN.

Trait Implementations

impl Clone for TypeIdent

fn clone(&self) -> TypeIdent

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TypeIdent

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

Formats the value using the given formatter.

impl Display for TypeIdent

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

Formats the value using the given formatter.

impl Hash for TypeIdent

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 TypeIdent

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

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

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

fn type_hash<H: Hasher>(&self, hasher: &mut H, types: &MetaTypes)

Feeds this value into the given Hasher.

fn type_eq(&self, other: &Self, types: &MetaTypes) -> bool

Check if this instance is equal to the other instance using the passed types to resolve identifiers.

fn type_hash_slice<H: Hasher>(slice: &[Self], hasher: &mut H, types: &MetaTypes)

Feeds a slice of this value into the given Hasher.

fn type_eq_iter<'a, X, Y>(x: X, y: Y, types: &MetaTypes) -> bool

where Self: 'a, X: IntoIterator<Item = &'a Self>, Y: IntoIterator<Item = &'a Self>,

Check if the two passed iterators contain type equal elements.

impl Eq for TypeIdent

impl StructuralPartialEq for TypeIdent