Struct DataContainer 

pub struct DataContainer {
    pub df: Arc<DataFrame>,
    pub df_original: Arc<DataFrame>,
    pub extension: Arc<FileExtension>,
    pub filter: Arc<DataFilter>,
    pub format: Arc<DataFormat>,
    pub sort: Vec<SortBy>,
}

Container for the Polars DataFrame and its associated display and filter state.

State Management:

• Holds the core data (df, df_original) and related settings.
• df: The currently displayed DataFrame, potentially sorted based on self.sort.
• df_original: The DataFrame state immediately after loading/querying, before UI sorts.
• filter: Configuration used for loading the data (path, delimiter, SQL query, etc.). Does NOT contain sorting information.
• format: Configuration for displaying the data (alignment, decimals, etc.).
• sort: Vec<SortBy> defining the active sort order applied to df. An empty Vec means df reflects df_original.
• All key components are wrapped in Arc for efficient cloning and sharing between UI and async tasks.
• Updates (load, format, sort) typically create new DataContainer instances via async methods.

Interaction with layout.rs:

• PolarsViewApp holds the current state as Option<Arc<DataContainer>>.
• UI actions trigger async methods here (load_data, update_format, apply_sort).
• Async methods return PolarsViewResult<DataContainer> via a channel.
• layout.rs updates the app state with the received new container.

Fields

df: Arc<DataFrame>

The currently displayed Polars DataFrame. May be sorted according to self.sort.

df_original: Arc<DataFrame>

A reference to the DataFrame state before any UI-driven sort was applied. Allows resetting the view efficiently.

extension: Arc<FileExtension>

Detected file extension of the originally loaded data.

filter: Arc<DataFilter>

Filters and loading configurations (path, query, delimiter) that resulted in the initial df_original. This does NOT store the current sort state.

format: Arc<DataFormat>

Applied data formatting settings (decimal places, alignment, column sizing, header style).

sort: Vec<SortBy>

The active sort criteria (column name and direction) applied to df. An empty vector signifies that df should be the same as df_original. Order in the vector determines sort precedence.

Implementations

impl DataContainer

pub async fn load_data( self, filter: DataFilter, format: DataFormat, ) -> PolarsViewResult<Self>

Asynchronously loads data or applies transformations based on DataFilter. Returns a new DataContainer state (taken and returned by value). This function coordinates the sequence of transformations using the Strategy pattern.

Flow:

1. Get the initial DataFrame value (either by reading file or cloning df_original) via prepare_initial_dataframe. This also updates self.extension, self.df_original, and filter.schema_without_index if a file was read.
2. Build the pipeline vector transformations by pushing concrete strategy instances based on flags in the filter.
3. Reset filter.apply_sql flag if SQL transformation was included in the pipeline.
4. Execute the pipeline: Iterate through the transformations vector, calling apply on each, chaining the output DataFrame.
5. Update the final filter.schema based on the DataFrame’s state after all transformations.
6. Update self.df, self.filter, self.format, and reset self.sort with the results of this operation.
7. Return the modified self.

pub async fn update_format(self, format: DataFormat) -> PolarsViewResult<Self>

Asynchronously creates a new DataContainer with updated format settings. Preserves the existing data (df, df_original) and sort criteria (sort).

Triggered by layout.rs when format UI elements change. This is a very fast operation.

pub async fn apply_sort( self, new_sort_criteria: Vec<SortBy>, ) -> PolarsViewResult<Self>

Asynchronously creates a new DataContainer with the df sorted according to the provided new_sort_criteria.

Triggered by layout.rs after a user clicks a sortable header, resulting in new criteria. Handles multi-column sorting based on the order, direction, and nulls_last settings in new_sort_criteria. If new_sort_criteria is empty, it resets the view by setting df to df_original.

Logic & State Update:

1. Check if new_sort_criteria is empty.
2. Handle Empty (Reset): If empty, create new container:
   • df: Cloned Arc of the input df_original.
   • df_original: Cloned Arc of the input df_original.
   • sort: The empty new_sort_criteria vector.
   • Other fields cloned from input container.
3. Handle Non-Empty (Apply Sort): If not empty: a. Extract column names, descending flags, and nulls_last flags from new_sort_criteria. b. Configure Polars SortMultipleOptions. c. Call data_container.df.sort() using the currently displayed df as input. d. Create new container:
   • df: New Arc wrapping the sorted DataFrame.
   • df_original: Cloned Arc of the input df_original.
   • sort: The new_sort_criteria that caused this sort.
   • Other fields cloned from input container.
4. Return Ok(new_container).

pub fn render_table(&self, ui: &mut Ui) -> Option<Vec<SortBy>>

Renders the main data table using egui_extras::TableBuilder. Handles sort interactions via render_table_header.

Returns Some(new_sort_criteria) if a header click requires a sort state update.

Trait Implementations

impl Clone for DataContainer

fn clone(&self) -> DataContainer

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DataContainer

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

Formats the value using the given formatter.

impl Default for DataContainer

fn default() -> Self

Creates an empty DataContainer with default settings.