#[derive(Debug, Clone, Copy, PartialEq)]
pub struct SizePolicy {
pub min: f32,
pub preferred: f32,
pub max: f32,
pub stretch: f32,
}
impl SizePolicy {
pub fn fixed(px: f32) -> Self {
Self {
min: px,
preferred: px,
max: px,
stretch: 0.0,
}
}
pub fn expand(stretch: f32) -> Self {
Self {
min: 0.0,
preferred: 0.0,
max: f32::INFINITY,
stretch: stretch.max(0.0),
}
}
pub fn between(min: f32, preferred: f32, max: f32, stretch: f32) -> Self {
let min = min.max(0.0);
let preferred = preferred.max(min);
let max = max.max(preferred);
Self {
min,
preferred,
max,
stretch: stretch.max(0.0),
}
}
}
pub fn distribute(total: f32, policies: &[SizePolicy]) -> Vec<f32> {
if policies.is_empty() {
return Vec::new();
}
let total = total.max(0.0);
let mut sizes: Vec<f32> = policies.iter().map(|p| p.min).collect();
let used: f32 = sizes.iter().sum();
if used >= total {
if used == 0.0 {
return sizes;
}
let scale = total / used;
for s in &mut sizes {
*s *= scale;
}
return sizes;
}
let leftover = total - used;
let stretch_sum: f32 = policies.iter().map(|p| p.stretch).sum();
if stretch_sum > 0.0 {
for (i, p) in policies.iter().enumerate() {
let extra = leftover * (p.stretch / stretch_sum);
sizes[i] = (sizes[i] + extra).min(p.max);
}
} else {
let n = policies.len() as f32;
for (i, p) in policies.iter().enumerate() {
let extra = leftover / n;
sizes[i] = (sizes[i] + extra).min(p.max);
}
}
let used: f32 = sizes.iter().sum();
if used < total - 0.01 {
let mut best: Option<usize> = None;
let mut best_stretch = f32::NEG_INFINITY;
for (i, p) in policies.iter().enumerate() {
if sizes[i] < p.max && p.stretch >= best_stretch {
best_stretch = p.stretch;
best = Some(i);
}
}
if let Some(i) = best {
sizes[i] = (sizes[i] + (total - used)).min(policies[i].max);
}
}
sizes
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn distribute_fixed_and_stretch() {
assert!(distribute(100.0, &[]).is_empty());
let s = distribute(100.0, &[SizePolicy::fixed(20.0), SizePolicy::expand(1.0)]);
assert!((s[0] - 20.0).abs() < 0.01);
assert!((s[1] - 80.0).abs() < 0.01);
let even = distribute(
90.0,
&[
SizePolicy::between(10.0, 10.0, 1000.0, 0.0),
SizePolicy::between(10.0, 10.0, 1000.0, 0.0),
],
);
assert!((even[0] - 45.0).abs() < 0.01);
let stuck = distribute(90.0, &[SizePolicy::fixed(10.0), SizePolicy::fixed(10.0)]);
assert!((stuck[0] - 10.0).abs() < 0.01);
let squeezed = distribute(10.0, &[SizePolicy::fixed(20.0), SizePolicy::fixed(20.0)]);
assert!((squeezed[0] - 5.0).abs() < 0.01);
let zero = distribute(0.0, &[SizePolicy::expand(1.0)]);
assert_eq!(zero[0], 0.0);
let capped = distribute(
200.0,
&[
SizePolicy::between(10.0, 10.0, 30.0, 1.0),
SizePolicy::expand(1.0),
],
);
assert!(capped[0] <= 30.0);
assert!(capped[1] > 100.0);
let two_stretch = distribute(100.0, &[SizePolicy::expand(1.0), SizePolicy::expand(3.0)]);
assert!(two_stretch[1] > two_stretch[0]);
let leftover = distribute(
100.0,
&[
SizePolicy::between(0.0, 0.0, 20.0, 1.0),
SizePolicy::between(0.0, 0.0, 1000.0, 0.0),
],
);
assert!(leftover[0] <= 20.0 + 0.01);
assert!(leftover[1] > 50.0);
let _ = SizePolicy::between(10.0, 5.0, 8.0, -1.0);
assert_eq!(distribute(0.0, &[SizePolicy::fixed(0.0)]), vec![0.0]);
let rem = distribute(
80.0,
&[
SizePolicy::between(10.0, 10.0, 15.0, 1.0),
SizePolicy::between(10.0, 10.0, 200.0, 1.0),
],
);
assert!(rem[0] <= 15.01);
assert!(rem[1] >= 60.0);
}
}