Shared via Rust Playground

playground.rs

use std::collections::HashMap;
use std::iter::FromIterator;

#[derive(Copy,Clone,PartialEq, Debug)]
enum VarRep {
    Attached(i32),
    NotAttached,
    Removed(i32),
}
use VarRep::*;


#[derive(Copy, Clone, PartialEq, Eq, Hash)]
struct Var(usize);


struct Model {
    vars: HashMap<Var, VarRep>,
    varcnt: usize,
}


impl Model {
    fn new() -> Model {
        Model {
            vars: HashMap::new(),
            varcnt: 0,
        }
    }

    fn add_var(&mut self) -> Var {
        let var = Var(self.varcnt);

        self.vars.insert(var, NotAttached);
        self.varcnt += 1;

        var
    }

    fn update(&mut self) {
        let newvars: Vec<_> = {
            let (added, removed): (Vec<_>, Vec<_>) =
                self.vars.iter().partition(|&(_, &rep)| match rep {
                    Removed(_) => false,
                    _ => true,
                });
            // call GRBdelvars to delete `removed`.

            added.iter()
                .enumerate()
                .map(|(newidx, &(&v, _))| (v, Attached(newidx as i32)))
                .collect()
        };
        self.vars = HashMap::from_iter(newvars.into_iter());
    }
}

fn main() {
    let mut model = Model::new();

    let x = model.add_var();
    let y = model.add_var();

    assert_eq!(*model.vars.get(&x).unwrap(), NotAttached);
    assert_eq!(*model.vars.get(&y).unwrap(), NotAttached);

    model.update();

    assert_eq!(*model.vars.get(&x).unwrap(), Attached(0));
    assert_eq!(*model.vars.get(&y).unwrap(), Attached(1));
}