Struct CodeGenerator 

pub struct CodeGenerator { /* private fields */ }

Main code generator struct that orchestrates specialized generators

Uses Arc<Mutex<>> for shared mutable state to enable parallel generation of independent StructureDefinitions via rayon.

Implementations

impl CodeGenerator

pub fn new(config: CodegenConfig) -> Self

Create a new code generator with the given configuration

pub fn new_with_value_set_directory<P: AsRef<Path>>( config: CodegenConfig, value_set_dir: P, ) -> Self

Create a new code generator with a ValueSet directory

pub fn load_structure_definition<P: AsRef<Path>>( &self, path: P, ) -> CodegenResult<StructureDefinition>

Load and parse a FHIR StructureDefinition from a JSON file

pub fn generate_struct( &mut self, structure_def: &StructureDefinition, ) -> CodegenResult<RustStruct>

Generate a Rust struct from a FHIR StructureDefinition

pub fn generate_trait( &mut self, structure_def: &StructureDefinition, ) -> CodegenResult<Vec<RustTrait>>

Generate traits for a structure definition

pub fn generate_to_organized_directories<P: AsRef<Path>>( &mut self, structure_def: &StructureDefinition, base_output_dir: P, ) -> CodegenResult<()>

Generate a Rust struct and write it to the appropriate directory based on FHIR type classification

pub fn generate_trait_to_organized_directory<P: AsRef<Path>>( &mut self, structure_def: &StructureDefinition, base_output_dir: P, ) -> CodegenResult<()>

Generate traits and write them to the traits directory

pub fn classify_fhir_structure_def( &self, structure_def: &StructureDefinition, ) -> FhirTypeCategory

Classify a FHIR StructureDefinition into the appropriate category

pub fn generate_to_file<P: AsRef<Path>>( &mut self, structure_def: &StructureDefinition, output_path: P, ) -> CodegenResult<()>

Generate a Rust struct and write it to a file

pub fn generate_trait_to_file<P: AsRef<Path>>( &mut self, structure_def: &StructureDefinition, output_path: P, ) -> CodegenResult<()>

Generate a Rust trait and write it to a file

pub fn pre_register_value_set_enums<P: AsRef<Path>>( &mut self, package_dir: P, ) -> CodegenResult<()>

Pre-scan and register all ValueSet enums in the TypeRegistry This should be called before processing resources to ensure correct import paths

pub fn generate_enum_files<P: AsRef<Path>>( &mut self, enums_dir: P, ) -> CodegenResult<()>

Generate all ValueSet enums to separate files in the specified directory

pub fn generate_enums_mod_file<P: AsRef<Path>>( &mut self, enums_dir: P, ) -> CodegenResult<()>

Generate a mod.rs file that re-exports all the enum modules

pub fn generate_enum_for_value_set( &mut self, value_set_url: &str, ) -> CodegenResult<Option<RustEnum>>

Generate an enum for a value set binding

pub fn has_cached_enums(&self) -> bool

Check if any ValueSet enums have been generated

pub fn to_filename(&self, structure_def: &StructureDefinition) -> String

Convert a FHIR resource type name to filename using snake_case

pub fn pre_generate_base_definitions( &mut self, structure_defs: &[StructureDefinition], )

Pre-generate base definitions (Element, BackboneElement, DomainResource, Resource) to ensure they’re in the type_cache before parallel generation begins.

These core FHIR types are referenced by virtually every other type, so generating them first eliminates lock contention during the parallel phase and avoids redundant re-generation attempts.

pub fn generate_trait_file_from_trait<P: AsRef<Path>>( &self, rust_trait: &RustTrait, output_path: P, ) -> CodegenResult<()>

Generate a trait file directly from a RustTrait object

pub fn type_cache_snapshot(&self) -> HashMap<String, RustStruct>

Get a clone of the shared type cache (for reading generated structs)

pub fn generate_structs_parallel( &self, structure_defs: &[StructureDefinition], ) -> Vec<(String, CodegenResult<RustStruct>)>

Generate Rust structs for multiple StructureDefinitions in parallel using rayon.

This processes the CPU-intensive struct generation phase in parallel while maintaining thread-safe access to shared state via Arc<Mutex<>>. Returns a vector of (StructureDefinition, Result) pairs.

Performance

On a machine with N cores, this typically achieves ~N× speedup for the struct generation phase compared to sequential processing, as each StructureDefinition’s struct generation is largely independent.

The TypeRegistry must be fully populated (Phase 1 complete) before calling this.

pub fn write_all_generated_files<P: AsRef<Path>>( &self, structure_defs: &[StructureDefinition], base_output_dir: P, ) -> Vec<CodegenResult<()>>

Generate files for all generated structs in the type cache.

This is the I/O phase that writes generated Rust code to disk. It should be called after generate_structs_parallel (or sequential generation) has populated the type cache.

pub fn write_all_trait_files<P: AsRef<Path>>( &self, structure_defs: &[StructureDefinition], base_output_dir: P, ) -> Vec<CodegenResult<()>>

Generate trait files for all resources and profiles in parallel.

This writes trait files for resources/profiles that have been generated.