Struct Generator

pub struct Generator<'types> { /* private fields */ }

Type that is used to generate rust code from a Types object.

Implementations

impl<'types> Generator<'types>

pub fn new(types: &'types Types) -> Self

Create a new code generator from the passed types.

pub fn xsd_parser_crate<S: Display>(self, value: S) -> Self

Set the name of the xsd-parser create that the generator should use for generating the code.

pub fn derive<I>(self, value: I) -> Self

where I: IntoIterator, I::Item: Display,

Set the traits the generated types should derive from.

Default is Debug and Clone.

Examples

let generator = Generator::new(types)
    .derive(["Debug", "Clone", "Eq", "PartialEq", "Ord", "PartialOrd"]);

pub fn dyn_type_traits<I>(self, value: I) -> Self

where I: IntoIterator, I::Item: Into<String>,

Set the traits that should be implemented by dynamic types.

The passed values must be valid type paths.

Examples

let generator = Generator::new(types)
    .dyn_type_traits(["core::fmt::Debug", "core::any::Any"]);

pub fn box_flags(self, value: BoxFlags) -> Self

Set the BoxFlags flags the generator should use for generating the code.

pub fn typedef_mode(self, value: TypedefMode) -> Self

Set the TypedefMode value the generator should use for generating the code.

pub fn serde_support(self, value: SerdeSupport) -> Self

Set the SerdeSupport value the generator should use for generating the code.

pub fn flags(self, value: GeneratorFlags) -> Self

Set the GeneratorFlags flags the generator should use for generating the code.

pub fn with_flags(self, value: GeneratorFlags) -> Self

Add the passed GeneratorFlags flags the generator should use for generating the code.

pub fn with_type_postfix<S: Into<String>>( self, type_: IdentType, postfix: S, ) -> Self

Set the postfixes the generator should use for the different types.

Default is "Type" for the IdentType::Type type and "" for the other types.

pub fn with_type(self, ident: Ident) -> Result<Self, Error>

Add a custom implemented type to the generator.

This will add a custom implemented type to the generator. These types are usually implemented and provided by the user of the generated code. The generator will just reference to the type definition and will not generate any code related to this type.

Errors

Returns an error if the namespace of the passed identifier is unknown.

Examples

let generator = Generator::new(types)
    .with_type(Ident::type_("UserDefinedType"));

pub fn generate_type( self, ident: Ident, ) -> Result<GeneratorFixed<'types>, Error>

Will fix the generator by call into_fixed and then generate_type.

pub fn generate_all_types(self) -> Result<GeneratorFixed<'types>, Error>

Will fix the generator by call into_fixed and then generate_all_types.

Errors

Will just forward the errors from generate_all_types.

pub fn into_fixed(self) -> GeneratorFixed<'types>

Will convert the generator into a GeneratorFixed.

Trait Implementations

impl<'types> Debug for Generator<'types>

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

Formats the value using the given formatter.