Struct NestedClassBuilder 

pub struct NestedClassBuilder { /* private fields */ }

Builder for creating NestedClass table entries.

NestedClassBuilder provides a fluent API for creating entries in the NestedClass metadata table, which defines hierarchical relationships between nested types and their enclosing types.

Purpose

The NestedClass table serves several key functions:

• Type Hierarchy: Defines which types are nested within other types
• Visibility Scoping: Establishes access rules for nested types
• Enclosing Context: Links nested types to their containing types
• Namespace Resolution: Enables proper type resolution within nested contexts
• Compilation Support: Provides context for type compilation and loading

Builder Pattern

The builder provides a fluent interface for constructing NestedClass entries:

let nesting_token = NestedClassBuilder::new()
    .nested_class(inner_row)
    .enclosing_class(outer_row)
    .build(&mut assembly)?;

Validation

The builder enforces the following constraints:

• Nested Class Required: A nested class token must be provided
• Enclosing Class Required: An enclosing class token must be provided
• Token Validation: Both tokens must be valid TypeDef tokens
• Relationship Validation: Prevents invalid nesting scenarios (self-nesting, etc.)

Integration

NestedClass entries integrate with other metadata structures:

• TypeDef: Both nested and enclosing types must be TypeDef entries
• Type Registry: Establishes relationships in the type system
• Visibility Rules: Nested types inherit accessibility from their context

Implementations

impl NestedClassBuilder

pub fn new() -> Self

Creates a new NestedClassBuilder instance.

Returns a builder with all fields unset, ready for configuration through the fluent API methods.

Examples

let builder = NestedClassBuilder::new();

pub fn nested_class(self, nested_class_row: u32) -> Self

Sets the row index of the nested type.

The nested type must be a valid TypeDef row index or placeholder that represents the type being nested within the enclosing type.

Arguments

• nested_class_row - Row index (or placeholder) of the TypeDef for the nested type

Examples

let inner_token = TypeDefBuilder::new()
    .name("InnerClass")
    .flags(TypeAttributes::NESTED_PUBLIC | TypeAttributes::CLASS)
    .build(&mut assembly)?;

let builder = NestedClassBuilder::new()
    .nested_class(inner_token.placeholder());

pub fn enclosing_class(self, enclosing_class_row: u32) -> Self

Sets the row index of the enclosing type.

The enclosing type must be a valid TypeDef row index or placeholder that represents the type containing the nested type.

Arguments

• enclosing_class_row - Row index (or placeholder) of the TypeDef for the enclosing type

Examples

let outer_token = TypeDefBuilder::new()
    .name("OuterClass")
    .public_class()
    .build(&mut assembly)?;

let builder = NestedClassBuilder::new()
    .enclosing_class(outer_token.placeholder());

pub fn build(self, assembly: &mut CilAssembly) -> Result<ChangeRefRc>

Builds the NestedClass entry and adds it to the assembly.

This method validates all required fields, verifies the type tokens are valid TypeDef tokens, validates the nesting relationship, creates the NestedClass table entry, and returns the metadata token for the new entry.

Arguments

• assembly - The CilAssembly being modified

Returns

Returns the metadata token for the newly created NestedClass entry.

Errors

Returns an error if:

• The nested class token is not set
• The enclosing class token is not set
• Either token is not a valid TypeDef token
• The tokens refer to the same type (self-nesting)
• There are issues adding the table row

Examples

let nesting_token = NestedClassBuilder::new()
    .nested_class(inner_row)
    .enclosing_class(outer_row)
    .build(&mut assembly)?;

println!("Created NestedClass with token: {:?}", nesting_token);

Trait Implementations

impl Clone for NestedClassBuilder

fn clone(&self) -> NestedClassBuilder

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for NestedClassBuilder

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

Formats the value using the given formatter.

impl Default for NestedClassBuilder

fn default() -> Self

Returns the “default value” for a type.