Struct IdentQuadruple 

pub struct IdentQuadruple {
    pub ns: Option<NamespaceIdent>,
    pub schema: Option<SchemaIdent>,
    pub name: String,
    pub type_: IdentType,
}

Identifier that is used inside the config.

Each element in a XML schema is uniquely identified by the following four values: - The namespace of the element (or no namespace at all). - The schema the element was defined in. - The name of the element. - The type of element.

This struct is used to bundle these three information to a unique identifier for an element.

Fields

ns: Option<NamespaceIdent>

Namespace where the type is defined in.

schema: Option<SchemaIdent>

Id of the schema the type is defined in.

name: String

Name of the type.

type_: IdentType

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

Implementations

impl IdentQuadruple

pub fn new<S>(name: S, type_: IdentType) -> Self

where S: Into<String>,

Create a new IdentQuadruple instance from the passed name and type_.

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

where X: Into<NamespaceIdent>,

Adds a NamespaceIdent to this identifier quadruple.

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

where X: Into<SchemaIdent>,

Adds a SchemaIdent to this identifier quadruple.

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

where X: Into<String>,

Sets the name of the type that is identified by this identifier quadruple.

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

Sets the identifier type of this identifier quadruple.

pub fn resolve(self, schemas: &Schemas) -> Result<TypeIdent, InterpreterError>

Resolve the quadruple to an actual type identifier that is available in the schema.

///

Caution This may end up in a type with the schema not fully resolved. This can happen if you specified the wrong schema name, or schema location. If you didn’t provide a SchemaIdent at all, the type is resolved by it’s name, which is also not always successful, if the type is not defined in the root of the available schemas.

If you use this to get suitable identifiers to define types for the interpreter (see with_type), then you are fine, because the interpreter will resolve unknown schema IDs by it’s own.

If you want to use the resolved identifier for selecting a MetaType from the resulting MetaTypes structure created by the interpreted, you have to resolve the type additionally using the IdentCache, which is also returned by the Interpreter (see exec_interpreter_with_ident_cache).

Errors

Returns an error if the namespace or the namespace prefix could not be resolved.

Trait Implementations

impl Clone for IdentQuadruple

fn clone(&self) -> IdentQuadruple

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for IdentQuadruple

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

Formats the value using the given formatter.

impl<N, S, X> From<(IdentType, N, Option<S>, X)> for IdentQuadruple

where N: Into<NamespaceIdent>, S: Into<SchemaIdent>, X: Into<String>,

fn from((type_, ns, schema, name): (IdentType, N, Option<S>, X)) -> Self

Converts to this type from the input type.

impl<N, S, X> From<(IdentType, N, S, X)> for IdentQuadruple

where N: Into<NamespaceIdent>, S: Into<SchemaIdent>, X: Into<String>,

fn from((type_, ns, schema, name): (IdentType, N, S, X)) -> Self

Converts to this type from the input type.

impl<N, X> From<(IdentType, N, X)> for IdentQuadruple

where N: Into<NamespaceIdent>, X: Into<String>,

fn from((type_, ns, name): (IdentType, N, X)) -> Self

Converts to this type from the input type.

impl<N, S, X> From<(IdentType, Option<N>, Option<S>, X)> for IdentQuadruple

where N: Into<NamespaceIdent>, S: Into<SchemaIdent>, X: Into<String>,

fn from((type_, ns, schema, name): (IdentType, Option<N>, Option<S>, X)) -> Self

Converts to this type from the input type.

impl<N, S, X> From<(IdentType, Option<N>, S, X)> for IdentQuadruple

where N: Into<NamespaceIdent>, S: Into<SchemaIdent>, X: Into<String>,

fn from((type_, ns, schema, name): (IdentType, Option<N>, S, X)) -> Self

Converts to this type from the input type.

impl<N, X> From<(IdentType, Option<N>, X)> for IdentQuadruple

where N: Into<NamespaceIdent>, X: Into<String>,

fn from((type_, ns, name): (IdentType, Option<N>, X)) -> Self

Converts to this type from the input type.

impl<X> From<(IdentType, X)> for IdentQuadruple

where X: AsRef<str>,

fn from((type_, ident): (IdentType, X)) -> Self

Converts to this type from the input type.