Compiler Explorer

Source code

// Shared vocabulary, "Doodads" with data in them

#[derive(Clone, Debug)]
struct Doodad {
    #[allow(dead_code)]
    numbers: [f64; 360],
}

// A: Code for some source of Doodads, faked for our demo

#[derive(Debug)]
struct Source(u16);

impl Source {
    fn make() -> Self {
        Source(5)
    }

fn take(&mut self) -> Option<Vec<Doodad>> {
        match self.0 {
            5 => { self.0 -= 1; Some(vec![Doodad { numbers: [1.1; 360]}; 19]) }
            4 => { self.0 -= 1; Some(vec![Doodad { numbers: [2.22; 360]}; 14]) }
            3 => { self.0 -= 1; Some(vec![Doodad { numbers: [3.333; 360]}; 18]) }
            2 => { self.0 -= 1; Some(vec![Doodad { numbers: [4.4444; 360]}; 12]) }
            1 => { self.0 -= 1; Some(vec![Doodad { numbers: [5.55555; 360]}; 6]) }
            _ => None
        }
    }
}

// B: Code which just uses the code from A to get some Doodads and store them in a Vec

#[derive(Copy, Clone, Debug)]
#[allow(dead_code)]
enum Policy {
    Bjarne,
    Cpp,
    Best,
}

use Policy::{Bjarne, Cpp, Best};

struct Gizmo {
    doodads: Vec<Doodad>,
    policy: Policy,
    copies: usize,
    allocs: usize,
}

impl Gizmo {
    fn new(policy: Policy) -> Self {
        println!("New Gizmo with growth policy: {policy:?}");
        Self { doodads: Vec::new(), policy, copies: 0, allocs: 0 }
    }

fn report(&self) {
        println!("{} Doodads were copied, {} Allocations were made",
            self.copies, self.allocs)
    }

fn extend(&mut self, doodads: &[Doodad]) {
        let mut cap = self.doodads.capacity();

println!(" The Gizmo has {} Doodads now and capacity for {} total",
            self.doodads.len(), cap);

match self.policy {
            Bjarne => {},
            Cpp => {
                println!(" Reserve space for these {}", doodads.len());
                self.doodads.reserve_exact(doodads.len());
            },
            Best => {
                println!(" Reserve space for these {}", doodads.len());
                self.doodads.reserve(doodads.len());
            },
        }

if cap != self.doodads.capacity() {
            self.copies += self.doodads.len();
            self.allocs += 1;
            cap = self.doodads.capacity();
        }

println!(" After any reservations are done its capacity is {}", cap);

println!(" Now we'll add the extra Doodads one at a time");

for doodad in doodads {
            self.doodads.push(doodad.clone());
            if cap != self.doodads.capacity() {
                self.copies += self.doodads.len() - 1;
                self.allocs += 1;
                cap = self.doodads.capacity();
                println!(" with len = {} we've been forced to grow, now capacity is {cap}",
                    self.doodads.len());
            }

}
        println!(" Now the Gizmo has len = {} and capacity = {}",
                self.doodads.len(), self.doodads.capacity());
    }
}

fn main() {
    // As written uses Bjarne's naive C++ policy, let the natural amortization do its thing
    // We can substitute the C++ reserve policy, destroying amortization
    // Or we can preserve amortization but still have reservation, clearly the Best policy
    let mut gizmo = Gizmo::new(Bjarne);

let mut source = Source::make();

while let Some(doodads) = source.take() {
        println!("Got {} more Doodads to put in the Gizmo", doodads.len());
        gizmo.extend(&doodads);
    }

println!("Done");
    gizmo.report();
}