flexmesh 0.1.3

Mutable mesh structure with persistent adjacency data and n-gon support
Documentation 
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

use std::collections::BTreeSet;

pub type NumType = u32;

#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]
pub struct Range {
    min: NumType,
    max: NumType
}

impl Range {
    pub fn new(min: NumType, max: NumType) -> Range {
        Range { min: min, max: max }
    }
}

pub struct RangeSet {
    available_ranges: BTreeSet<Range>
}

impl RangeSet {
    pub fn new(initial_range: Range) -> RangeSet {
        let mut rs = RangeSet { available_ranges: BTreeSet::new() };
        rs.available_ranges.insert(initial_range);
        rs
    }

    pub fn take_any_one(&mut self) -> Option<NumType> {
        if let Some(range) = self.next_range() {
            self.available_ranges.remove(&range);
            if range.min == range.max {
                Some(range.min)
            } else {
                self.available_ranges.insert(Range::new(1 + range.min,
                                                        range.max));
                Some(range.min)
            }
        } else {
            None
        }
    }

    fn next_range(&self) -> Option<Range> {
        if let Some(&range) = self.available_ranges.iter().next() {
            Some(range)
        } else {
            None
        }
    }

    pub fn release_one(&mut self, _: NumType) {
        // TODO(nicholasbishop): implement this
    }
}