1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
//! Examples of using `safe_index`.
//!
//! Do not use the types in this module.

/// Example of zero-cost wrapping. **Do not use this.**
///
/// ```
/// safe_index::new!{
///     /// Index of a variable.
///     VarIndex,
///     /// Range over `VarIndex`.
///     range: VarRange,
///     /// Set of variable indexes.
///     btree set: VarBSet,
///     /// Map of variable indexes.
///     btree map: VarBMap,
///     /// Vector indexed by variable indexes.
///     map: VarMap with iter: VarMapIter,
/// }
/// fn main() {
///     use std::mem::size_of;
///     assert_eq!( size_of::<VarIndex>(), size_of::<usize>() );
///     assert_eq!( size_of::<VarRange>(), 2 * size_of::<usize>() );
///     assert_eq!( size_of::<VarMap<String>>(), size_of::<Vec<String>>() );
///
///     let mut var_values = VarMap::with_capacity(3);
///     let v_0 = var_values.push(7);
///     let v_1 = var_values.push(3);
///     let v_2 = var_values.push(11);
///     assert_eq! { var_values[v_0], 7  }
///     assert_eq! { var_values[v_1], 3  }
///     assert_eq! { var_values[v_2], 11 }
///
///     let mut check = vec![11, 3, 7];
///     for val in &var_values {
///         assert_eq! { *val, check.pop().unwrap() }
///     }
///
///     let mut check = vec![(v_2, 11), (v_1, 3), (v_0, 7)];
///     for (idx, val) in var_values.index_iter() {
///         let (i, v) = check.pop().unwrap();
///         assert_eq! {  idx, i }
///         assert_eq! { *val, v }
///     }
///
///     let mut check = vec![11, 3, 7];
///     for idx in v_0.up_to( var_values.next_index() ) {
///         assert_eq! { var_values[idx], check.pop().unwrap() }
///     }
///
///     var_values.swap(v_0, v_2);
///     assert_eq! { var_values[v_0], 11 }
///     assert_eq! { var_values[v_1], 3  }
///     assert_eq! { var_values[v_2], 7  }
///
///     let val = var_values.swap_remove(v_0);
///     assert_eq! { var_values[v_0], 7 }
///     assert_eq! { var_values[v_1], 3  }
///     assert_eq! { val, 11  }
/// }
/// ```
pub mod basic {
    new! {
        /// Index of a variable.
        VarIndex,
        /// Range over `VarIndex`.
        range: VarRange,
        /// Set of variable indexes.
        btree set: VarBSet,
        /// Map of variable indexes.
        btree map: VarBMap,
        /// Vector indexed by variable indexes.
        map: VarMap with iter: VarMapIter,
    }

    #[test]
    fn run() {
        use std::mem::size_of;
        assert_eq!(size_of::<VarIndex>(), size_of::<usize>());
        assert_eq!(size_of::<VarRange>(), 2 * size_of::<usize>());
        assert_eq!(size_of::<VarMap<String>>(), size_of::<Vec<String>>());

        let mut var_values = VarMap::with_capacity(3);
        let v_0 = var_values.push(7);
        let v_1 = var_values.push(3);
        let v_2 = var_values.push(11);
        assert_eq! { var_values[v_0], 7  }
        assert_eq! { var_values[v_1], 3  }
        assert_eq! { var_values[v_2], 11 }

        let mut check = vec![11, 3, 7];
        for val in &var_values {
            assert_eq! { *val, check.pop().unwrap() }
        }

        let mut check = vec![(v_2, 11), (v_1, 3), (v_0, 7)];
        for (idx, val) in var_values.index_iter() {
            let (i, v) = check.pop().unwrap();
            assert_eq! {  idx, i }
            assert_eq! { *val, v }
        }

        let mut check = vec![11, 3, 7];
        for idx in v_0.up_to(var_values.next_index()) {
            assert_eq! { var_values[idx], check.pop().unwrap() }
        }

        var_values.swap(v_0, v_2);
        assert_eq! { var_values[v_0], 11 }
        assert_eq! { var_values[v_1], 3  }
        assert_eq! { var_values[v_2], 7  }

        let val = var_values.swap_remove(v_0);
        assert_eq! { var_values[v_0], 7 }
        assert_eq! { var_values[v_1], 3  }
        assert_eq! { val, 11  }
    }
}

pub mod clients;