lolicon_api 1.1.0

Lolicon API wrapper in Rust
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
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

use crate::DateAfter;
use crate::DateBefore;
use crate::Keyword;
use crate::Proxy;
use crate::Size;
use crate::Tag;
use crate::R18;

pub trait Argument {
    fn argument(&self, url: &mut String);
}

impl Argument for Option<R18> {
    fn argument(&self, url: &mut String) {
        if let Some(r) = self {
            let argument = match r {
                R18::NonR18 => return, // default behavior
                R18::R18 => "&r18=1",
                R18::Mixin => "&r18=2",
            };
            url.push_str(argument);
        }
    }
}

impl Argument for Option<u8> {
    fn argument(&self, url: &mut String) {
        if let Some(num) = self {
            let argument = format!("&num={}", num);
            url.push_str(&argument);
        }
    }
}

impl Argument for Option<Vec<u32>> {
    fn argument(&self, url: &mut String) {
        if let Some(uid_list) = self {
            for uid in uid_list {
                let argument = format!("&uid={}", uid);
                url.push_str(&argument);
            }
        }
    }
}

impl Argument for Keyword {
    fn argument(&self, url: &mut String) {
        if let Keyword(Some(key)) = self {
            let argument = format!("&keyword={}", key);
            url.push_str(&argument);
        }
    }
}

impl Argument for Tag {
    fn argument(&self, url: &mut String) {
        if let Tag(Some(ref tag_list)) = self {
            for tag in tag_list {
                let argument = format!("&tag={}", tag);
                url.push_str(&argument);
            }
        }
    }
}

impl Argument for Size {
    fn argument(&self, url: &mut String) {
        if let Size(Some(ref size_list)) = self {
            for size in size_list {
                let argument = format!("&size={}", size);
                url.push_str(&argument);
            }
        }
    }
}

impl Argument for Proxy {
    fn argument(&self, url: &mut String) {
        if let Proxy(Some(ref proxy)) = self {
            let argument = format!("&proxy={}", proxy);
            url.push_str(&argument);
        }
    }
}

impl Argument for DateAfter {
    fn argument(&self, url: &mut String) {
        if let DateAfter(Some(date)) = self {
            let argument = format!("&dataAfter={}", date);
            url.push_str(&argument);
        }
    }
}

impl Argument for DateBefore {
    fn argument(&self, url: &mut String) {
        if let DateBefore(Some(date)) = self {
            let argument = format!("&dataBefore={}", date);
            url.push_str(&argument);
        }
    }
}

impl Argument for Option<bool> {
    fn argument(&self, url: &mut String) {
        if let Some(dsc) = self {
            let argument = format!("&dsc={:?}", dsc);
            url.push_str(&argument);
        }
    }
}