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(vec!["Debug", "Clone", "Eq", "PartialEq", "Ord", "PartialOrd"]);

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

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

pub fn content_mode(self, value: ContentMode) -> Self

Set the ContentMode value 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 generate_flags(self, value: GenerateFlags) -> Self

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

pub fn with_generate_flags(self, value: GenerateFlags) -> Self

Add the passed GenerateFlags 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<Self, Error>

Generate the code for the given type.

This will generate the code for the passed type identifier and all dependencies of this type.

Examples

let generator = Generator::new(types)
    .generate_type(Ident::type_("Root"));

pub fn generate_all_types(self) -> Result<Self, Error>

Generate the code for all types.

This will generate the code for all types and all dependencies of this type that are specified in the Types object passed to the generator.

Examples

let generator = Generator::new(types)
    .generate_all_types();

pub fn finish(self) -> TokenStream

Finish the code generation.

THis will return the generated code as TokenStream.

Trait Implementations

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

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

Formats the value using the given formatter.