lprun 0.2.0

a library for running and managing LOVE binaries
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
55
56
57
58
59
60
61
62
63
64
65

use platform_lp::Platform;
use version_lp::Version;

use std::fmt;
use std::collections::HashSet;

/// Internal struct to describe a LOVE release.
#[derive(Hash,Eq,PartialEq,Serialize,Deserialize,SmartHash)]
pub struct Release {
    pub version : Version,
    pub platform: Platform,
    pub link : String,
}

impl fmt::Display for Release {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f,"{}-{}",self.platform,self.version)
    }
}

impl std::cmp::Ord for Release {
    fn cmp(&self, other: &Release) -> std::cmp::Ordering {
        self.version.cmp(&other.version)
    }
}

impl std::cmp::PartialOrd for Release {
    fn partial_cmp(&self, other: &Release) -> Option<std::cmp::Ordering> {
        Some(self.cmp(other))
    }
}

/// created this struct because serializing and deserializing 
/// a HashSet doesn't work.
#[derive(Hash,Eq,PartialEq,Serialize,Deserialize)]
pub struct ReleaseExporter {
    pub releases : Vec<Release>,
}

impl ReleaseExporter {
    pub fn from_release(mut releases : HashSet<Release>) -> ReleaseExporter {
        let mut vec : Vec<Release>= Vec::new();

        for release in releases.drain() {
            vec.push(release);
        }

        ReleaseExporter {
            releases : vec,
        }
    }

    pub fn to_release(mut self) -> HashSet<Release> {
        let mut hash : HashSet<Release> = HashSet::new();

        loop {
            match self.releases.pop() {
                Some(release) => { hash.insert(release); },
                None => { break; },
            }
        }

        hash
    }
}