Struct ModuleUnit

pub struct ModuleUnit {
    pub name: String,
    pub attributes: Vec<String>,
    pub doc: Option<String>,
    pub declares: Vec<DeclareStatements>,
    pub visibility: Visibility,
    pub functions: Vec<FunctionUnit>,
    pub structs: Vec<StructUnit>,
    pub traits: Vec<TraitUnit>,
    pub impls: Vec<ImplUnit>,
    pub submodules: Vec<ModuleUnit>,
    pub source: Option<String>,
}

Represents a module in the code

Fields

name: String

The name of the module

attributes: Vec<String>

Attributes applied to the module

doc: Option<String>

The document for the module

declares: Vec<DeclareStatements>

The declares in the module, e.g. imports, use statements, mod statements, c includes, python/js imports, etc.

visibility: Visibility

The visibility of the module

functions: Vec<FunctionUnit>

Functions defined in the module

structs: Vec<StructUnit>

Structs defined in the module

traits: Vec<TraitUnit>

Traits defined in the module

impls: Vec<ImplUnit>

Implementation blocks defined in the module

submodules: Vec<ModuleUnit>

Sub-modules defined in the module

source: Option<String>

Source code of the module declaration

Implementations

impl ModuleUnit

Implementation of ModuleUnit.

Examples

use codebank::{ModuleUnit, Visibility};

// Create a new public module
let module = ModuleUnit::new(
    "example".to_string(),
    Visibility::Public,
    Some("Module documentation".to_string()),
);

assert_eq!(module.name, "example");
assert!(matches!(module.visibility, Visibility::Public));
assert_eq!(module.doc, Some("Module documentation".to_string()));
assert!(module.functions.is_empty());
assert!(module.structs.is_empty());
assert!(module.traits.is_empty());
assert!(module.impls.is_empty());
assert!(module.submodules.is_empty());

pub fn new(name: String, visibility: Visibility, doc: Option<String>) -> Self

Creates a new module unit with the given name, visibility, and documentation.

Arguments

• name - The name of the module
• visibility - The visibility level of the module
• document - Optional documentation for the module

Examples

use codebank::{ModuleUnit, Visibility};

let module = ModuleUnit::new(
    "my_module".to_string(),
    Visibility::Public,
    Some("Module docs".to_string()),
);

assert_eq!(module.name, "my_module");

Trait Implementations

impl Debug for ModuleUnit

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

Formats the value using the given formatter.

impl Default for ModuleUnit

fn default() -> ModuleUnit

Returns the “default value” for a type.

impl Formatter for ModuleUnit

fn format( &self, strategy: &BankStrategy, language: LanguageType, ) -> Result<String>