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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157

use crate::structs::ApiStation;
use crate::StationOrder;
use async_std::task;
use std::error::Error;

#[derive(Clone, Debug)]
pub struct StationSearchBuilder {
    builder: crate::StationSearchBuilder,
}

impl StationSearchBuilder {
    pub fn new(builder: crate::StationSearchBuilder) -> Self {
        StationSearchBuilder { builder }
    }

    pub fn name<P: AsRef<str>>(self, name: P) -> Self {
        StationSearchBuilder {
            builder: self.builder.name(name),
        }
    }

    pub fn name_exact(self, name_exact: bool) -> Self {
        StationSearchBuilder {
            builder: self.builder.name_exact(name_exact),
        }
    }

    pub fn country<P: AsRef<str>>(self, country: P) -> Self {
        StationSearchBuilder {
            builder: self.builder.country(country),
        }
    }

    pub fn country_exact(self, country_exact: bool) -> Self {
        StationSearchBuilder {
            builder: self.builder.country_exact(country_exact),
        }
    }

    pub fn countrycode<P: AsRef<str>>(self, countrycode: P) -> Self {
        StationSearchBuilder {
            builder: self.builder.countrycode(countrycode),
        }
    }

    pub fn state<P: AsRef<str>>(self, state: P) -> Self {
        StationSearchBuilder {
            builder: self.builder.state(state),
        }
    }

    pub fn state_exact(self, state_exact: bool) -> Self {
        StationSearchBuilder {
            builder: self.builder.state_exact(state_exact),
        }
    }

    pub fn language<P: AsRef<str>>(self, language: P) -> Self {
        StationSearchBuilder {
            builder: self.builder.language(language),
        }
    }

    pub fn language_exact(self, language_exact: bool) -> Self {
        StationSearchBuilder {
            builder: self.builder.language_exact(language_exact),
        }
    }

    pub fn tag<P: AsRef<str>>(self, tag: P) -> Self {
        StationSearchBuilder {
            builder: self.builder.tag(tag),
        }
    }

    pub fn tag_exact(self, tag_exact: bool) -> Self {
        StationSearchBuilder {
            builder: self.builder.tag_exact(tag_exact),
        }
    }

    pub fn tag_list(self, tags: Vec<&str>) -> Self {
        StationSearchBuilder {
            builder: self.builder.tag_list(tags),
        }
    }

    pub fn codec<P: AsRef<str>>(self, codec: P) -> Self {
        StationSearchBuilder {
            builder: self.builder.codec(codec),
        }
    }

    pub fn bitrate_min(self, bitrate_min: u16) -> Self {
        StationSearchBuilder {
            builder: self.builder.bitrate_min(bitrate_min),
        }
    }

    pub fn bitrate_max(self, bitrate_max: u16) -> Self {
        StationSearchBuilder {
            builder: self.builder.bitrate_max(bitrate_max),
        }
    }

    pub fn has_geo_info(self, has_geo_info: bool) -> Self {
        StationSearchBuilder {
            builder: self.builder.has_geo_info(has_geo_info),
        }
    }

    pub fn has_extended_info(self, has_extended_info: bool) -> Self {
        StationSearchBuilder {
            builder: self.builder.has_extended_info(has_extended_info),
        }
    }

    pub fn is_https(self, is_https: bool) -> Self {
        StationSearchBuilder {
            builder: self.builder.is_https(is_https),
        }
    }

    pub fn order(self, order: StationOrder) -> Self {
        StationSearchBuilder {
            builder: self.builder.order(order),
        }
    }

    pub fn reverse(self, reverse: bool) -> Self {
        StationSearchBuilder {
            builder: self.builder.reverse(reverse),
        }
    }

    pub fn offset<P: AsRef<str>>(self, offset: P) -> Self {
        StationSearchBuilder {
            builder: self.builder.offset(offset),
        }
    }

    pub fn limit<P: AsRef<str>>(self, limit: P) -> Self {
        StationSearchBuilder {
            builder: self.builder.limit(limit),
        }
    }

    pub fn hidebroken(self, hidebroken: bool) -> Self {
        StationSearchBuilder {
            builder: self.builder.hidebroken(hidebroken),
        }
    }

    pub fn send(self) -> Result<Vec<ApiStation>, Box<dyn Error>> {
        task::block_on(async { self.builder.send().await })
    }
}