redox 0.0.3

A library implementing the bittorrent protocol and a few key extensions.
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

//! 

use std::iter;

pub struct TierList<'a> {
    tiers: Vec<Vec<&'a str>>
}

impl<'a> TierList<'a> {
    pub fn new(tier_list: Vec<Vec<&'a str>>) -> TierList<'a> {
        TierList{ tiers: tier_list }
    }
    
    pub fn iter<'b>(&'b mut self) -> TierIter<'a, 'b> {
        TierIter{ tiers: &mut self.tiers[..], index: 0 }
    }
}

pub struct TierIter<'a: 'b, 'b> {
    tiers: &'b mut [Vec<&'a str>],
    index: usize
}

impl<'a: 'b, 'b: 'c, 'c> Iterator for TierIter<'a, 'b> {
    type Item = Tier<'a, 'c>;
    
    fn next(&mut self) -> Option<<Self as Iterator>::Item> {
        if self.index >= self.tiers.len() {
            None
        } else {
            self.index += 1;
            Some(Tier{ tier: &mut self.tiers[self.index - 1][..] })
        }
    }
}

pub struct Tier<'a: 'b, 'b> {
    tier: &'b mut [&'a str]
}

impl<'a: 'b, 'b> Tier<'a, 'b> {
    pub fn check_tier<F>(&mut self, is_active: F) -> bool 
        where F: Fn(&str) -> bool {
        let mut active_index = -1;
        let mut active_url = "";
    
        for (index, url) in self.tier.iter().enumerate() {
            if is_active(url) {
                active_index = index;
                active_url = url;
                
                break;
            }
        }
        
        if active_index != -1 {
            for i in iter::range_step_inclusive(active_index - 1, 0, 1) {
                let move_value = self.tier[i];
                
                self.tier[i + 1] = move_value;
            }
            self.tier[0] = active_url;
        
            true
        } else {
            false
        }
    }
}