Struct ColumnRegistry 

pub(crate) struct ColumnRegistry<'a> {
    pub(crate) columns: Vec<ResolvedColumn>,
    pub(crate) col_index: HashMap<String, usize>,
    pub(crate) coerce_to_string: bool,
    pub(crate) string_ty: &'a Type,
}

Accumulates unique columns for an enum-to-dataframe unified schema.

As columns are registered from each variant’s fields, the registry detects duplicates and validates type consistency. When coerce_to_string is enabled, type conflicts are resolved by coercing to String; otherwise they produce errors.

Fields

columns: Vec<ResolvedColumn>

The ordered list of resolved columns in the schema.

col_index: HashMap<String, usize>

Maps column name strings to their index in columns for O(1) dedup lookup.

coerce_to_string: bool

Whether to coerce type-conflicting columns to String instead of erroring.

string_ty: &'a Type

Cached String type AST node, used as the coercion target type.

Implementations

impl<'a> ColumnRegistry<'a>

fn new(coerce_to_string: bool, string_ty: &'a Type) -> Self

Create a new empty column registry.

fn register( &mut self, col_name: &str, col_ty: &Type, variant_idx: usize, variant_name: &Ident, error_span: Span, ) -> Result<()>

Register a single column in the schema, or merge with an existing column.

If a column with the same name already exists, validates that the types match. On type conflict: coerces to String (if coerce_to_string is true) or returns Err. The variant_idx is appended to the column’s present_in list.

pub(crate) fn register_factor( &mut self, col_name: &str, col_ty: &Type, variant_idx: usize, variant_name: &Ident, error_span: Span, ) -> Result<()>

Like register, but marks the column as a factor column (is_factor = true).

Used for fields annotated with #[dataframe(as_factor)]. The companion struct field type stays Vec<Option<T>>, but into_data_frame wraps it in FactorOptionVec<T> (using the UnitEnumFactor blanket IntoR impl).

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 88 bytes