Struct Context

Source

pub struct Context<'a, 'types> {
    pub meta: &'a MetaData<'types>,
    pub data: &'a DataType<'types>,
    pub ident: &'a TypeIdent,
    pub values: Values,
    /* private fields */
}

Expand description

Context for the rendering process.

This contains different additional information and configuration that may be needed by a Renderer to render the actual code. It is also used to collect the rendered code and add it to the corresponding module.

Fields§

§meta: &'a MetaData<'types>

Meta information for the rendering process.

§data: &'a DataType<'types>

Data type that needs to be rendered.

§ident: &'a TypeIdent

Identifier of the data type that needs to be rendered.

§values: Values

Generic data storage for any type that implements ValueKey.

Implementations§

Source §

impl<'a, 'types> Context<'a, 'types>

Source

pub fn resolve_type_for_module(&self, target_type: &PathData) -> TokenStream

Resolves the passed ident relative to the module of the current rendered type.

Source

pub fn resolve_build_in(&self, path: &str) -> IdentPath

Resolves the passed identifier path for build-in types before it can be rendered.

If GeneratorFlags::BUILD_IN_ABSOLUTE_PATHS is set, the path is returned as it, otherwise it will return the identifier only (without the path).

§Panics

Panics if the passed path is not a valid IdentPath.

Source

pub fn resolve_ident_path(&self, path: &str) -> IdentPath

Resolve the passed identifier path before it can be rendered.

If GeneratorFlags::ABSOLUTE_PATHS_INSTEAD_USINGS is set this will returns the path as is, otherwise it will add a suitable using (see add_usings) and returns the identifier only (without the path).

Source

pub fn add_usings(&self, usings: I)
where I: IntoIterator, I::Item: ToString,

Add using directives to the module the of the current rendered type.

Source

pub fn add_root_usings(&self, usings: I)
where I: IntoIterator, I::Item: ToString,

Add using directives to the root module.

Source

pub fn main_module(&mut self) -> &mut Module

Returns a mutable reference to the main module.

This might be useful if you need to add code anywhere to the generated result.

Source

pub fn current_module(&mut self) -> &mut Module

Returns a mutable reference to the module of the current rendered type.

Source

pub fn set<K>(&mut self, value: K::Type)
where K: ValueKey,

Set a value for the specified key K.

Source

pub fn get<K>(&self) -> K::Type
where K: ValueKey, K::Type: Clone,

Get the value that was stored for the specified key K.

Panics if the key was not set before.

Source

pub fn get_ref<K>(&self) -> &K::Type
where K: ValueKey,

Get a reference to the value that was stored for the specified key K.

Panics if the key was not set before.

Source

pub fn get_mut<K>(&mut self) -> &mut K::Type
where K: ValueKey,

Get a mutable reference to the value that was stored for the specified key K.

Panics if the key was not set before.

Source

pub fn get_or_create<K>(&mut self) -> &mut K::Type
where K: ValueKey, K::Type: Default,

Get a mutable reference to the value that was stored for the specified key K. If no value is available a new one is created.

Source

pub fn get_or_create_with<K, F>(&mut self, f: F) -> &mut K::Type
where K: ValueKey, F: FnOnce() -> K::Type,

Get a mutable reference to the value that was stored for the specified key K. If no value is available a new one is created with the provided function f.

Source

pub fn extract<K>(&mut self) -> K::Type
where K: ValueKey,

Extracts the value stored for the specified key K.

Panics if the key was not set before.

Source

pub fn unset<K>(&mut self)
where K: ValueKey,

Removes any values for the specified key K.

Source

pub fn patch_usings( &self, usings: I, ) -> impl Iterator<Item = String> + use<'_, I>
where I: IntoIterator, I::Item: ToString,

Takes an iterator of usings (anything that implements ToString) and executes patch_using for each element.

Source

pub fn patch_using<'x>(&self, using: Cow<'x, str>) -> Cow<'x, str>

Replaces the alloc:: and xsd_parser:: in the path with the configured name for the alloc and xsd-parser crate.

See Renderer::alloc_crate and Renderer::xsd_parser_types for details.

This should be used before you add using directives to a module manually. Normally you should use add_usings which does the patching automatically, but if you want to add code somewhere in the module tree, this might be useful.

Methods from Deref<Target = MetaData<'types>>§

Source

pub fn check_renderer_flags(&self, flags: RendererFlags) -> bool

Whether the passed flags intersect with the renderer flags set in the configuration, or not.

Methods from Deref<Target = GeneratorMetaData<'types>>§

Source

pub fn check_generator_flags(&self, flags: GeneratorFlags) -> bool

Whether the passed flags intersect with the generator flags set in the configuration, or not.

Methods from Deref<Target = MetaTypes>§

Source

pub fn name_builder(&self) -> Box<dyn NameBuilderTrait>

Create a new boxed NameBuilder, that can be used to build type names.

Source

pub fn get_resolved<'a>( &'a self, ident: &'a TypeIdent, ) -> Option<(&'a TypeIdent, &'a MetaType)>

Get the identifier and the type of the passed ident with all single type references resolved.

Tries to find the type specified by the passed ident and resolve simple type definitions to the very base type. If the type could not be found None is returned.

Source