Struct GenericSize 

pub struct GenericSize<T> { /* private fields */ }

Generic size value object with type-safe size categories

Purpose

Type-safe size measurement that provides:

• Compile-time size category enforcement (File vs Memory vs Network)
• Shared arithmetic and conversion operations
• Zero-cost abstractions with phantom types
• Category-specific validation and constraints

Generic Benefits

• Type Safety: Cannot mix file sizes with memory sizes at compile time
• Code Reuse: Shared implementation for all size types
• Extensibility: Easy to add new size categories
• Zero Cost: Phantom types have no runtime overhead

Use Cases

• File size management and validation
• Memory allocation tracking
• Network bandwidth measurement
• Storage capacity planning

Cross-Language Mapping

• Rust: GenericSize<T> with marker types

Examples

• Go: Separate types with shared interface
• JSON: Number with unit metadata
• SQLite: INTEGER with category column

Implementations

impl<T: SizeCategory> GenericSize<T>

pub fn new(bytes: u64) -> Result<Self, PipelineError>

Creates a new size with category-specific validation

Purpose

Creates a type-safe size value with category-specific validation. Uses phantom types to prevent mixing different size categories at compile time.

Why

Type-safe sizes provide:

• Compile-time prevention of mixing file/memory/network sizes
• Category-specific validation and constraints
• Zero-cost abstractions with phantom types
• Clear API contracts for size requirements

Arguments

• bytes - Size in bytes (validated against category limits)

Returns

• Ok(GenericSize<T>) - Valid size for category T
• Err(PipelineError::InvalidConfiguration) - Exceeds category maximum

Errors

Returns error when size exceeds category-specific maximum:

• File sizes: 10 TB maximum
• Memory sizes: 1 TB maximum
• Network sizes: 100 GB per transfer
• Storage sizes: essentially unlimited

Examples

pub fn zero() -> Self

Creates a zero size

pub fn from_kb(kb: u64) -> Result<Self, PipelineError>

Creates size from kilobytes

pub fn from_mb(mb: u64) -> Result<Self, PipelineError>

Creates size from megabytes

Purpose

Convenience constructor for creating sizes from megabyte values. Automatically converts to bytes and validates.

Why

MB-based construction provides:

• Human-readable size specification
• Common unit for file and memory sizes
• Overflow protection during conversion
• Category validation

Arguments

• mb - Size in megabytes (1 MB = 1,048,576 bytes)

Returns

• Ok(GenericSize<T>) - Valid size
• Err(PipelineError) - Overflow or validation error

Errors

• Multiplication overflow during byte conversion
• Category maximum exceeded

Examples

pub fn from_gb(gb: u64) -> Result<Self, PipelineError>

Creates size from gigabytes

pub fn bytes(&self) -> u64

Gets the raw byte count

pub fn category(&self) -> &'static str

Gets the size category name

pub fn into_category<U: SizeCategory>( self, ) -> Result<GenericSize<U>, PipelineError>

Converts to a different size category (with validation)

pub fn as_kb(&self) -> u64

Gets size as kilobytes

pub fn as_mb(&self) -> u64

Gets size as megabytes

pub fn as_gb(&self) -> u64

Gets size as gigabytes

pub fn as_mb_f64(&self) -> f64

Gets size as floating point megabytes

pub fn as_gb_f64(&self) -> f64

Gets size as floating point gigabytes

pub fn is_zero(&self) -> bool

Checks if size is zero

pub fn human_readable(&self) -> String

Formats as human-readable string

pub fn checked_add(&self, other: Self) -> Result<Self, PipelineError>

Safely adds sizes (checked arithmetic)

pub fn checked_sub(&self, other: Self) -> Result<Self, PipelineError>

Safely subtracts sizes (checked arithmetic)

pub fn validate(&self) -> Result<(), PipelineError>

Validates the size

impl GenericSize<FileSizeMarker>

Specialized methods for different size categories

pub fn is_large_file(&self) -> bool

Checks if this is a large file (> 1 GB)

pub fn transfer_time_seconds(&self, bandwidth_mbps: f64) -> f64

Estimates transfer time for given bandwidth (MB/s)

impl GenericSize<MemorySizeMarker>

pub fn is_page_aligned(&self) -> bool

Checks if this is aligned to page boundaries (typically 4KB)

pub fn round_up_to_page(&self) -> MemorySize

Rounds up to next page boundary

pub fn is_reasonable_allocation(&self) -> bool

Checks if size is reasonable for allocation

impl GenericSize<NetworkSizeMarker>

pub fn optimal_chunk_size(&self) -> NetworkSize

Gets optimal chunk size for network transfer

pub fn estimated_round_trips(&self, mtu: u64) -> u64

Estimates number of network round trips

impl GenericSize<StorageSizeMarker>

pub fn as_tb(&self) -> u64

Converts to storage units (TB, PB)

pub fn monthly_cost(&self, cost_per_gb: f64) -> f64

Gets storage cost estimate ($/month at given rate per GB)

Trait Implementations

impl<T: SizeCategory> Add for GenericSize<T>

type Output = GenericSize<T>

The resulting type after applying the + operator.

fn add(self, rhs: GenericSize<T>) -> Self::Output

Performs the + operation.

impl<T: Clone> Clone for GenericSize<T>

fn clone(&self) -> GenericSize<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for GenericSize<T>

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

Formats the value using the given formatter.

impl<T: SizeCategory> Default for GenericSize<T>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for GenericSize<T>

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: SizeCategory> Display for GenericSize<T>

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

Formats the value using the given formatter.

impl<T: SizeCategory> Div<u64> for GenericSize<T>

type Output = GenericSize<T>

The resulting type after applying the / operator.

fn div(self, rhs: u64) -> Self::Output

Performs the / operation.

impl<T> From<GenericSize<T>> for u64

fn from(size: GenericSize<T>) -> Self

Converts to this type from the input type.

impl<T> From<u64> for GenericSize<T>

fn from(bytes: u64) -> Self

Converts to this type from the input type.

impl<T: Hash> Hash for GenericSize<T>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: SizeCategory> Mul<u64> for GenericSize<T>

type Output = GenericSize<T>

The resulting type after applying the * operator.

fn mul(self, rhs: u64) -> Self::Output

Performs the * operation.

impl<T: Ord> Ord for GenericSize<T>

fn cmp(&self, other: &GenericSize<T>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T: PartialEq> PartialEq for GenericSize<T>

fn eq(&self, other: &GenericSize<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: PartialOrd> PartialOrd for GenericSize<T>

fn partial_cmp(&self, other: &GenericSize<T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T> Serialize for GenericSize<T>

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: SizeCategory> Sub for GenericSize<T>

type Output = GenericSize<T>

The resulting type after applying the - operator.

fn sub(self, rhs: GenericSize<T>) -> Self::Output

Performs the - operation.

impl<T: Copy> Copy for GenericSize<T>

impl<T: Eq> Eq for GenericSize<T>

impl<T> StructuralPartialEq for GenericSize<T>