Trait SummaryCalculator 

pub trait SummaryCalculator {
    // Required methods
    fn add_rest_dates(
        self,
        rest_dates: HashSet<NaiveDate>,
        duration: Duration,
    ) -> Self;
    fn calculate_totals(self) -> (Self, Duration, Duration)
       where Self: Sized;
}

Trait for processing and enhancing collections of daily summaries.

This trait provides the core business logic for preparing monthly reports by integrating actual work data with organizational calendar information. It ensures comprehensive coverage of all calendar days and provides statistical analysis capabilities.

Design Philosophy

The trait follows a functional programming approach with method chaining:

use kasl::libs::summary::{DailySummary, SummaryCalculator};
use chrono::Duration;
use std::collections::HashSet;

let summaries: Vec<DailySummary> = vec![];
let company_holidays = HashSet::new();
let default_hours = Duration::hours(8);

let result = summaries
    .add_rest_dates(company_holidays, default_hours)
    .calculate_totals();

This design enables:

• Composability: Methods can be chained for complex transformations
• Immutability: Each method returns a new collection
• Readability: Clear sequence of data processing steps
• Testability: Each transformation can be tested independently

Implementation Strategy

Implementations should handle:

• Data Completeness: Ensure all calendar days are represented
• Duplicate Prevention: Avoid duplicate entries for the same date
• Statistical Accuracy: Provide meaningful aggregate calculations
• Performance: Efficient processing of month-long datasets

Required Methods

fn add_rest_dates( self, rest_dates: HashSet<NaiveDate>, duration: Duration, ) -> Self

Integrates company rest days into the summary collection.

This method ensures comprehensive monthly coverage by adding entries for company holidays, weekends, and other non-working days that should be included in monthly reports. It prevents gaps in monthly summaries and provides complete calendar coverage.

Integration Logic

The method processes rest dates as follows:

1. Existence Check: Verifies if a summary already exists for each rest date
2. Gap Filling: Adds new summary entries for missing rest dates
3. Default Values: Assigns standard work hours and zero productivity
4. Duplicate Prevention: Skips rest dates that already have work data

Default Duration Rationale

Rest days are assigned default work hours for several reasons:

• Payroll Integration: Many payroll systems expect standard hours
• Monthly Targets: Helps meet monthly hour requirements
• Benefit Allocation: Paid holidays contribute to monthly totals
• Reporting Consistency: Provides predictable monthly hour calculations

Productivity Handling

Rest days are assigned 0.0% productivity because:

• Accuracy: No actual work was performed
• Statistical Integrity: Prevents artificial inflation of productivity metrics
• Clear Distinction: Differentiates between work days and rest days
• Analysis: Enables separate analysis of work vs. rest day patterns

Arguments

• rest_dates - Set of dates that are company holidays or rest days
• duration - Default work duration to assign to rest days (typically 8 hours)

Returns

Returns a new collection with rest days integrated, maintaining the original work data while filling gaps with rest day entries.

Examples

use kasl::libs::summary::{DailySummary, SummaryCalculator};
use std::collections::HashSet;
use chrono::{Duration, NaiveDate};

let work_summaries: Vec<DailySummary> = vec![];
let mut rest_dates = HashSet::new();
rest_dates.insert(NaiveDate::from_ymd_opt(2025, 8, 15).unwrap()); // Company holiday

let enhanced_summaries = work_summaries
    .add_rest_dates(rest_dates, Duration::hours(8));

fn calculate_totals(self) -> (Self, Duration, Duration)

where Self: Sized,

Calculates comprehensive statistics for the summary collection.

This method performs the final aggregation step to produce monthly statistics including total work hours, average daily hours, and other metrics needed for reporting and analysis.

Statistical Calculations

Total Duration

• Sum: Aggregates all daily durations in the collection
• Includes: Both work days and rest days with default hours
• Purpose: Monthly hour totals for payroll and reporting

Average Duration

• Formula: Total duration divided by number of days
• Significance: Daily hour target and performance benchmarking
• Accuracy: Reflects realistic daily work expectations

Data Preparation

Before calculation, the method:

1. Sorts summaries by date for consistent processing
2. Validates data integrity and completeness
3. Handles edge cases like empty collections
4. Optimizes calculations for performance

Return Value Structure

Returns a tuple containing:

• Enhanced Collection: Sorted and processed summary data
• Total Duration: Sum of all daily durations
• Average Duration: Mean daily duration across all days

Returns

A tuple of (Self, Duration, Duration) where:

• First element: Processed and sorted summary collection
• Second element: Total duration across all days
• Third element: Average duration per day

Examples

use kasl::libs::summary::{DailySummary, SummaryCalculator};
use kasl::libs::formatter::format_duration;
use std::collections::HashSet;
use chrono::Duration;

let summaries: Vec<DailySummary> = vec![];
let rest_dates = HashSet::new();

let (processed_summaries, total_hours, average_daily) = summaries
    .add_rest_dates(rest_dates, Duration::hours(8))
    .calculate_totals();

println!("Total monthly hours: {}", format_duration(&total_hours));
println!("Average daily hours: {}", format_duration(&average_daily));

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl SummaryCalculator for Vec<DailySummary>

fn add_rest_dates( self, rest_dates: HashSet<NaiveDate>, duration: Duration, ) -> Self

Integrates company rest days into the daily summary collection.

This implementation provides the standard logic for incorporating organizational rest days into monthly work summaries. It ensures complete calendar coverage while preserving existing work data.

Implementation Details

Duplicate Detection

Uses an efficient lookup strategy:

• Creates a temporary set of existing dates for O(1) lookups
• Checks each rest date against existing summaries
• Only adds entries for truly missing dates

Memory Efficiency

• Pre-allocates space for new entries to minimize reallocations
• Uses iterator chains to avoid intermediate collections
• Processes rest dates in batch for optimal performance

Data Consistency

• Maintains the same data structure and field meanings
• Uses consistent duration and productivity value assignment
• Preserves the ability to distinguish between work and rest days

Arguments

• rest_dates - HashSet of dates to be added as rest days
• duration - Standard duration to assign (typically 8 hours)

Returns

A new Vec with rest days integrated

fn calculate_totals(self) -> (Self, Duration, Duration)

Calculates total and average durations for the summary collection.

This implementation provides comprehensive statistical analysis of the monthly work data, producing both raw totals and meaningful averages for reporting purposes.

Processing Steps

1. Data Sorting

• Sorts summaries chronologically by date
• Ensures consistent ordering for reports and analysis
• Facilitates pattern recognition in work data

2. Total Calculation

• Uses iterator fold for efficient aggregation
• Handles Duration arithmetic correctly
• Accumulates across all days in the collection

3. Average Calculation

• Divides total by actual number of days
• Handles edge case of empty collections gracefully
• Provides realistic daily work expectations

Error Handling

• Empty Collection: Returns zero values for both total and average
• Invalid Durations: Negative durations are treated as zero
• Overflow Protection: Uses checked arithmetic where appropriate

Performance Characteristics

• Time Complexity: O(n log n) due to sorting requirement
• Space Complexity: O(1) additional space for calculations
• Memory Usage: In-place sorting minimizes memory overhead

Returns

Tuple containing:

• Sorted summary collection
• Total duration across all days
• Average duration per day

Implementors