8 8 | impl From<crate::unconstrained::constrained_union_unconstrained::ConstrainedUnionUnconstrained>
|
9 9 | for crate::constrained::MaybeConstrained<crate::model::ConstrainedUnion>
|
10 10 | {
|
11 11 | fn from(
|
12 12 | value: crate::unconstrained::constrained_union_unconstrained::ConstrainedUnionUnconstrained,
|
13 13 | ) -> Self {
|
14 14 | Self::Unconstrained(value)
|
15 15 | }
|
16 16 | }
|
17 17 |
|
18 - | pub(crate) mod map_of_enum_string_unconstrained {
|
18 + | pub(crate) mod map_of_length_string_unconstrained {
|
19 19 |
|
20 20 | #[derive(Debug, Clone)]
|
21 - | pub(crate) struct MapOfEnumStringUnconstrained(
|
21 + | pub(crate) struct MapOfLengthStringUnconstrained(
|
22 22 | pub(crate) std::collections::HashMap<::std::string::String, ::std::string::String>,
|
23 23 | );
|
24 24 |
|
25 - | impl From<MapOfEnumStringUnconstrained>
|
25 + | impl From<MapOfLengthStringUnconstrained>
|
26 26 | for crate::constrained::MaybeConstrained<
|
27 - | crate::constrained::map_of_enum_string_constrained::MapOfEnumStringConstrained,
|
27 + | crate::constrained::map_of_length_string_constrained::MapOfLengthStringConstrained,
|
28 28 | >
|
29 29 | {
|
30 - | fn from(value: MapOfEnumStringUnconstrained) -> Self {
|
30 + | fn from(value: MapOfLengthStringUnconstrained) -> Self {
|
31 31 | Self::Unconstrained(value)
|
32 32 | }
|
33 33 | }
|
34 - | impl std::convert::TryFrom<MapOfEnumStringUnconstrained>
|
35 - | for crate::constrained::map_of_enum_string_constrained::MapOfEnumStringConstrained
|
34 + | impl std::convert::TryFrom<MapOfLengthStringUnconstrained>
|
35 + | for crate::constrained::map_of_length_string_constrained::MapOfLengthStringConstrained
|
36 36 | {
|
37 - | type Error = crate::model::map_of_enum_string::ConstraintViolation;
|
38 - | fn try_from(value: MapOfEnumStringUnconstrained) -> std::result::Result<Self, Self::Error> {
|
37 + | type Error = crate::model::map_of_length_string::ConstraintViolation;
|
38 + | fn try_from(
|
39 + | value: MapOfLengthStringUnconstrained,
|
40 + | ) -> std::result::Result<Self, Self::Error> {
|
39 41 | let res: ::std::result::Result<
|
40 - | ::std::collections::HashMap<crate::model::EnumString, crate::model::EnumString>,
|
42 + | ::std::collections::HashMap<crate::model::LengthString, crate::model::LengthString>,
|
41 43 | Self::Error,
|
42 44 | > = value
|
43 45 | .0
|
44 46 | .into_iter()
|
45 47 | .map(|(k, v)| {
|
46 - | let k: crate::model::EnumString = k.try_into().map_err(Self::Error::Key)?;
|
48 + | let k: crate::model::LengthString = k.try_into().map_err(Self::Error::Key)?;
|
47 49 |
|
48 - | match crate::model::EnumString::try_from(v) {
|
50 + | match crate::model::LengthString::try_from(v) {
|
49 51 | Ok(v) => Ok((k, v)),
|
50 52 | Err(inner_constraint_violation) => {
|
51 53 | Err(Self::Error::Value(k, inner_constraint_violation))
|
52 54 | }
|
53 55 | }
|
54 56 | })
|
55 57 | .collect();
|
56 58 | let hm = res?;
|
57 59 | Ok(Self(hm))
|
58 60 | }
|
59 61 | }
|
60 62 | }
|
61 - | pub(crate) mod con_b_map_unconstrained {
|
63 + | pub(crate) mod set_of_length_string_unconstrained {
|
62 64 |
|
63 65 | #[derive(Debug, Clone)]
|
64 - | pub(crate) struct ConBMapUnconstrained(
|
65 - | pub(crate) std::collections::HashMap<::std::string::String, ::std::string::String>,
|
66 + | pub(crate) struct SetOfLengthStringUnconstrained(
|
67 + | pub(crate) std::vec::Vec<::std::string::String>,
|
66 68 | );
|
67 69 |
|
68 - | impl From<ConBMapUnconstrained> for crate::constrained::MaybeConstrained<crate::model::ConBMap> {
|
69 - | fn from(value: ConBMapUnconstrained) -> Self {
|
70 + | impl From<SetOfLengthStringUnconstrained>
|
71 + | for crate::constrained::MaybeConstrained<crate::model::SetOfLengthString>
|
72 + | {
|
73 + | fn from(value: SetOfLengthStringUnconstrained) -> Self {
|
70 74 | Self::Unconstrained(value)
|
71 75 | }
|
72 76 | }
|
73 - | impl std::convert::TryFrom<ConBMapUnconstrained> for crate::model::ConBMap {
|
74 - | type Error = crate::model::con_b_map::ConstraintViolation;
|
75 - | fn try_from(value: ConBMapUnconstrained) -> std::result::Result<Self, Self::Error> {
|
77 + | impl std::convert::TryFrom<SetOfLengthStringUnconstrained> for crate::model::SetOfLengthString {
|
78 + | type Error = crate::model::set_of_length_string::ConstraintViolation;
|
79 + | fn try_from(
|
80 + | value: SetOfLengthStringUnconstrained,
|
81 + | ) -> std::result::Result<Self, Self::Error> {
|
76 82 | let res: ::std::result::Result<
|
77 - | ::std::collections::HashMap<::std::string::String, crate::model::LengthString>,
|
78 - | Self::Error,
|
83 + | ::std::vec::Vec<crate::model::LengthString>,
|
84 + | (usize, crate::model::length_string::ConstraintViolation),
|
79 85 | > = value
|
80 86 | .0
|
81 87 | .into_iter()
|
82 - | .map(|(k, v)| match crate::model::LengthString::try_from(v) {
|
83 - | Ok(v) => Ok((k, v)),
|
84 - | Err(inner_constraint_violation) => {
|
85 - | Err(Self::Error::Value(k, inner_constraint_violation))
|
86 - | }
|
88 + | .enumerate()
|
89 + | .map(|(idx, inner)| {
|
90 + | inner
|
91 + | .try_into()
|
92 + | .map_err(|inner_violation| (idx, inner_violation))
|
87 93 | })
|
88 94 | .collect();
|
89 - | let hm = res?;
|
90 - | Self::try_from(hm)
|
91 - | }
|
92 - | }
|
93 - | }
|
94 - | pub(crate) mod map_of_list_of_length_pattern_string_unconstrained {
|
95 - |
|
96 - | #[derive(Debug, Clone)]
|
97 - | pub(crate) struct MapOfListOfLengthPatternStringUnconstrained(pub(crate) std::collections::HashMap<::std::string::String, crate::unconstrained::list_of_length_pattern_string_unconstrained::ListOfLengthPatternStringUnconstrained>);
|
98 - |
|
99 - | impl From<MapOfListOfLengthPatternStringUnconstrained> for crate::constrained::MaybeConstrained<crate::constrained::map_of_list_of_length_pattern_string_constrained::MapOfListOfLengthPatternStringConstrained> {
|
100 - | fn from(value: MapOfListOfLengthPatternStringUnconstrained) -> Self {
|
101 - | Self::Unconstrained(value)
|
102 - | }
|
103 - | }
|
104 - | impl std::convert::TryFrom<MapOfListOfLengthPatternStringUnconstrained> for crate::constrained::map_of_list_of_length_pattern_string_constrained::MapOfListOfLengthPatternStringConstrained {
|
105 - | type Error = crate::model::map_of_list_of_length_pattern_string::ConstraintViolation;
|
106 - | fn try_from(value: MapOfListOfLengthPatternStringUnconstrained) -> std::result::Result<Self, Self::Error> {
|
107 - | let res: ::std::result::Result<::std::collections::HashMap<crate::model::LengthPatternString, crate::constrained::list_of_length_pattern_string_constrained::ListOfLengthPatternStringConstrained>, Self::Error> = value.0
|
108 - | .into_iter()
|
109 - | .map(|(k, v)| {
|
110 - | let k: crate::model::LengthPatternString = k.try_into().map_err(Self::Error::Key)?;
|
111 - |
|
112 - | match crate::constrained::list_of_length_pattern_string_constrained::ListOfLengthPatternStringConstrained::try_from(v) {
|
113 - | Ok(v) => Ok((k, v)),
|
114 - | Err(inner_constraint_violation) => Err(Self::Error::Value(k, inner_constraint_violation)),
|
115 - | }
|
116 - | })
|
117 - | .collect();
|
118 - | let hm = res?;
|
119 - | Ok(Self(hm))
|
120 - | }
|
121 - | }
|
122 - | }
|
123 - | pub(crate) mod list_of_length_pattern_string_unconstrained {
|
124 - |
|
125 - | #[derive(Debug, Clone)]
|
126 - | pub(crate) struct ListOfLengthPatternStringUnconstrained(
|
127 - | pub(crate) std::vec::Vec<::std::string::String>,
|
128 - | );
|
129 - |
|
130 - | impl From<ListOfLengthPatternStringUnconstrained> for crate::constrained::MaybeConstrained<crate::constrained::list_of_length_pattern_string_constrained::ListOfLengthPatternStringConstrained> {
|
131 - | fn from(value: ListOfLengthPatternStringUnconstrained) -> Self {
|
132 - | Self::Unconstrained(value)
|
133 - | }
|
134 - | }
|
135 - | impl std::convert::TryFrom<ListOfLengthPatternStringUnconstrained> for crate::constrained::list_of_length_pattern_string_constrained::ListOfLengthPatternStringConstrained {
|
136 - | type Error = crate::model::list_of_length_pattern_string::ConstraintViolation;
|
137 - | fn try_from(value: ListOfLengthPatternStringUnconstrained) -> std::result::Result<Self, Self::Error> {
|
138 - | let res: ::std::result::Result<::std::vec::Vec<crate::model::LengthPatternString>, (usize, crate::model::length_pattern_string::ConstraintViolation) > = value
|
139 - | .0
|
140 - | .into_iter()
|
141 - | .enumerate()
|
142 - | .map(|(idx, inner)| {
|
143 - | inner.try_into().map_err(|inner_violation| (idx, inner_violation))
|
144 - | })
|
145 - | .collect();
|
146 - | let inner = res
|
147 - |
|
148 - | .map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
|
149 - | Ok(Self(inner))
|
150 - | }
|
151 - | }
|
152 - | }
|
153 - | pub(crate) mod map_of_length_pattern_string_unconstrained {
|
154 - |
|
155 - | #[derive(Debug, Clone)]
|
156 - | pub(crate) struct MapOfLengthPatternStringUnconstrained(
|
157 - | pub(crate) std::collections::HashMap<::std::string::String, ::std::string::String>,
|
158 - | );
|
159 - |
|
160 - | impl From<MapOfLengthPatternStringUnconstrained> for crate::constrained::MaybeConstrained<crate::constrained::map_of_length_pattern_string_constrained::MapOfLengthPatternStringConstrained> {
|
161 - | fn from(value: MapOfLengthPatternStringUnconstrained) -> Self {
|
162 - | Self::Unconstrained(value)
|
163 - | }
|
164 - | }
|
165 - | impl std::convert::TryFrom<MapOfLengthPatternStringUnconstrained> for crate::constrained::map_of_length_pattern_string_constrained::MapOfLengthPatternStringConstrained {
|
166 - | type Error = crate::model::map_of_length_pattern_string::ConstraintViolation;
|
167 - | fn try_from(value: MapOfLengthPatternStringUnconstrained) -> std::result::Result<Self, Self::Error> {
|
168 - | let res: ::std::result::Result<::std::collections::HashMap<crate::model::LengthPatternString, crate::model::LengthPatternString>, Self::Error> = value.0
|
169 - | .into_iter()
|
170 - | .map(|(k, v)| {
|
171 - | let k: crate::model::LengthPatternString = k.try_into().map_err(Self::Error::Key)?;
|
172 - |
|
173 - | match crate::model::LengthPatternString::try_from(v) {
|
174 - | Ok(v) => Ok((k, v)),
|
175 - | Err(inner_constraint_violation) => Err(Self::Error::Value(k, inner_constraint_violation)),
|
176 - | }
|
177 - | })
|
178 - | .collect();
|
179 - | let hm = res?;
|
180 - | Ok(Self(hm))
|
181 - | }
|
182 - | }
|
183 - | }
|
184 - | pub(crate) mod map_of_list_of_pattern_string_unconstrained {
|
185 - |
|
186 - | #[derive(Debug, Clone)]
|
187 - | pub(crate) struct MapOfListOfPatternStringUnconstrained(pub(crate) std::collections::HashMap<::std::string::String, crate::unconstrained::list_of_pattern_string_unconstrained::ListOfPatternStringUnconstrained>);
|
188 - |
|
189 - | impl From<MapOfListOfPatternStringUnconstrained> for crate::constrained::MaybeConstrained<crate::constrained::map_of_list_of_pattern_string_constrained::MapOfListOfPatternStringConstrained> {
|
190 - | fn from(value: MapOfListOfPatternStringUnconstrained) -> Self {
|
191 - | Self::Unconstrained(value)
|
192 - | }
|
193 - | }
|
194 - | impl std::convert::TryFrom<MapOfListOfPatternStringUnconstrained> for crate::constrained::map_of_list_of_pattern_string_constrained::MapOfListOfPatternStringConstrained {
|
195 - | type Error = crate::model::map_of_list_of_pattern_string::ConstraintViolation;
|
196 - | fn try_from(value: MapOfListOfPatternStringUnconstrained) -> std::result::Result<Self, Self::Error> {
|
197 - | let res: ::std::result::Result<::std::collections::HashMap<crate::model::PatternString, crate::constrained::list_of_pattern_string_constrained::ListOfPatternStringConstrained>, Self::Error> = value.0
|
198 - | .into_iter()
|
199 - | .map(|(k, v)| {
|
200 - | let k: crate::model::PatternString = k.try_into().map_err(Self::Error::Key)?;
|
201 - |
|
202 - | match crate::constrained::list_of_pattern_string_constrained::ListOfPatternStringConstrained::try_from(v) {
|
203 - | Ok(v) => Ok((k, v)),
|
204 - | Err(inner_constraint_violation) => Err(Self::Error::Value(k, inner_constraint_violation)),
|
205 - | }
|
206 - | })
|
207 - | .collect();
|
208 - | let hm = res?;
|
209 - | Ok(Self(hm))
|
95 + | let inner =
|
96 + | res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
|
97 + | Self::try_from(inner)
|
210 98 | }
|
211 99 | }
|
212 100 | }
|
213 - | pub(crate) mod list_of_pattern_string_unconstrained {
|
101 + | pub(crate) mod list_of_length_string_unconstrained {
|
214 102 |
|
215 103 | #[derive(Debug, Clone)]
|
216 - | pub(crate) struct ListOfPatternStringUnconstrained(
|
104 + | pub(crate) struct ListOfLengthStringUnconstrained(
|
217 105 | pub(crate) std::vec::Vec<::std::string::String>,
|
218 106 | );
|
219 107 |
|
220 - | impl From<ListOfPatternStringUnconstrained>
|
108 + | impl From<ListOfLengthStringUnconstrained>
|
221 109 | for crate::constrained::MaybeConstrained<
|
222 - | crate::constrained::list_of_pattern_string_constrained::ListOfPatternStringConstrained,
|
110 + | crate::constrained::list_of_length_string_constrained::ListOfLengthStringConstrained,
|
223 111 | >
|
224 112 | {
|
225 - | fn from(value: ListOfPatternStringUnconstrained) -> Self {
|
113 + | fn from(value: ListOfLengthStringUnconstrained) -> Self {
|
226 114 | Self::Unconstrained(value)
|
227 115 | }
|
228 116 | }
|
229 - | impl std::convert::TryFrom<ListOfPatternStringUnconstrained>
|
230 - | for crate::constrained::list_of_pattern_string_constrained::ListOfPatternStringConstrained
|
117 + | impl std::convert::TryFrom<ListOfLengthStringUnconstrained>
|
118 + | for crate::constrained::list_of_length_string_constrained::ListOfLengthStringConstrained
|
231 119 | {
|
232 - | type Error = crate::model::list_of_pattern_string::ConstraintViolation;
|
120 + | type Error = crate::model::list_of_length_string::ConstraintViolation;
|
233 121 | fn try_from(
|
234 - | value: ListOfPatternStringUnconstrained,
|
122 + | value: ListOfLengthStringUnconstrained,
|
235 123 | ) -> std::result::Result<Self, Self::Error> {
|
236 124 | let res: ::std::result::Result<
|
237 - | ::std::vec::Vec<crate::model::PatternString>,
|
238 - | (usize, crate::model::pattern_string::ConstraintViolation),
|
125 + | ::std::vec::Vec<crate::model::LengthString>,
|
126 + | (usize, crate::model::length_string::ConstraintViolation),
|
239 127 | > = value
|
240 128 | .0
|
241 129 | .into_iter()
|
242 130 | .enumerate()
|
243 131 | .map(|(idx, inner)| {
|
244 132 | inner
|
245 133 | .try_into()
|
246 134 | .map_err(|inner_violation| (idx, inner_violation))
|
247 135 | })
|
248 136 | .collect();
|
249 137 | let inner =
|
250 138 | res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
|
251 139 | Ok(Self(inner))
|
252 140 | }
|
253 141 | }
|
254 142 | }
|
255 - | pub(crate) mod map_of_pattern_string_unconstrained {
|
143 + | pub(crate) mod length_list_of_pattern_string_unconstrained {
|
256 144 |
|
257 145 | #[derive(Debug, Clone)]
|
258 - | pub(crate) struct MapOfPatternStringUnconstrained(
|
259 - | pub(crate) std::collections::HashMap<::std::string::String, ::std::string::String>,
|
146 + | pub(crate) struct LengthListOfPatternStringUnconstrained(
|
147 + | pub(crate) std::vec::Vec<::std::string::String>,
|
260 148 | );
|
261 149 |
|
262 - | impl From<MapOfPatternStringUnconstrained>
|
263 - | for crate::constrained::MaybeConstrained<
|
264 - | crate::constrained::map_of_pattern_string_constrained::MapOfPatternStringConstrained,
|
265 - | >
|
150 + | impl From<LengthListOfPatternStringUnconstrained>
|
151 + | for crate::constrained::MaybeConstrained<crate::model::LengthListOfPatternString>
|
266 152 | {
|
267 - | fn from(value: MapOfPatternStringUnconstrained) -> Self {
|
153 + | fn from(value: LengthListOfPatternStringUnconstrained) -> Self {
|
268 154 | Self::Unconstrained(value)
|
269 155 | }
|
270 156 | }
|
271 - | impl std::convert::TryFrom<MapOfPatternStringUnconstrained>
|
272 - | for crate::constrained::map_of_pattern_string_constrained::MapOfPatternStringConstrained
|
157 + | impl std::convert::TryFrom<LengthListOfPatternStringUnconstrained>
|
158 + | for crate::model::LengthListOfPatternString
|
273 159 | {
|
274 - | type Error = crate::model::map_of_pattern_string::ConstraintViolation;
|
160 + | type Error = crate::model::length_list_of_pattern_string::ConstraintViolation;
|
275 161 | fn try_from(
|
276 - | value: MapOfPatternStringUnconstrained,
|
162 + | value: LengthListOfPatternStringUnconstrained,
|
277 163 | ) -> std::result::Result<Self, Self::Error> {
|
278 164 | let res: ::std::result::Result<
|
279 - | ::std::collections::HashMap<
|
280 - | crate::model::PatternString,
|
281 - | crate::model::PatternString,
|
282 - | >,
|
283 - | Self::Error,
|
165 + | ::std::vec::Vec<crate::model::PatternString>,
|
166 + | (usize, crate::model::pattern_string::ConstraintViolation),
|
284 167 | > = value
|
285 168 | .0
|
286 169 | .into_iter()
|
287 - | .map(|(k, v)| {
|
288 - | let k: crate::model::PatternString = k.try_into().map_err(Self::Error::Key)?;
|
289 - |
|
290 - | match crate::model::PatternString::try_from(v) {
|
291 - | Ok(v) => Ok((k, v)),
|
292 - | Err(inner_constraint_violation) => {
|
293 - | Err(Self::Error::Value(k, inner_constraint_violation))
|
294 - | }
|
295 - | }
|
170 + | .enumerate()
|
171 + | .map(|(idx, inner)| {
|
172 + | inner
|
173 + | .try_into()
|
174 + | .map_err(|inner_violation| (idx, inner_violation))
|
296 175 | })
|
297 176 | .collect();
|
298 - | let hm = res?;
|
299 - | Ok(Self(hm))
|
177 + | let inner =
|
178 + | res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
|
179 + | Self::try_from(inner)
|
300 180 | }
|
301 181 | }
|
302 182 | }
|
303 - | pub(crate) mod map_of_list_of_enum_string_unconstrained {
|
183 + | pub(crate) mod length_set_of_pattern_string_unconstrained {
|
304 184 |
|
305 185 | #[derive(Debug, Clone)]
|
306 - | pub(crate) struct MapOfListOfEnumStringUnconstrained(
|
307 - | pub(crate) std::collections::HashMap<
|
308 - | ::std::string::String,
|
309 - | crate::unconstrained::list_of_enum_string_unconstrained::ListOfEnumStringUnconstrained,
|
310 - | >,
|
311 - | );
|
312 - |
|
313 - | impl From<MapOfListOfEnumStringUnconstrained> for crate::constrained::MaybeConstrained<crate::constrained::map_of_list_of_enum_string_constrained::MapOfListOfEnumStringConstrained> {
|
314 - | fn from(value: MapOfListOfEnumStringUnconstrained) -> Self {
|
315 - | Self::Unconstrained(value)
|
316 - | }
|
317 - | }
|
318 - | impl std::convert::TryFrom<MapOfListOfEnumStringUnconstrained> for crate::constrained::map_of_list_of_enum_string_constrained::MapOfListOfEnumStringConstrained {
|
319 - | type Error = crate::model::map_of_list_of_enum_string::ConstraintViolation;
|
320 - | fn try_from(value: MapOfListOfEnumStringUnconstrained) -> std::result::Result<Self, Self::Error> {
|
321 - | let res: ::std::result::Result<::std::collections::HashMap<crate::model::EnumString, crate::constrained::list_of_enum_string_constrained::ListOfEnumStringConstrained>, Self::Error> = value.0
|
322 - | .into_iter()
|
323 - | .map(|(k, v)| {
|
324 - | let k: crate::model::EnumString = k.try_into().map_err(Self::Error::Key)?;
|
325 - |
|
326 - | match crate::constrained::list_of_enum_string_constrained::ListOfEnumStringConstrained::try_from(v) {
|
327 - | Ok(v) => Ok((k, v)),
|
328 - | Err(inner_constraint_violation) => Err(Self::Error::Value(k, inner_constraint_violation)),
|
329 - | }
|
330 - | })
|
331 - | .collect();
|
332 - | let hm = res?;
|
333 - | Ok(Self(hm))
|
334 - | }
|
335 - | }
|
336 - | }
|
337 - | pub(crate) mod list_of_enum_string_unconstrained {
|
338 - |
|
339 - | #[derive(Debug, Clone)]
|
340 - | pub(crate) struct ListOfEnumStringUnconstrained(
|
186 + | pub(crate) struct LengthSetOfPatternStringUnconstrained(
|
341 187 | pub(crate) std::vec::Vec<::std::string::String>,
|
342 188 | );
|
343 189 |
|
344 - | impl From<ListOfEnumStringUnconstrained>
|
345 - | for crate::constrained::MaybeConstrained<
|
346 - | crate::constrained::list_of_enum_string_constrained::ListOfEnumStringConstrained,
|
347 - | >
|
190 + | impl From<LengthSetOfPatternStringUnconstrained>
|
191 + | for crate::constrained::MaybeConstrained<crate::model::LengthSetOfPatternString>
|
348 192 | {
|
349 - | fn from(value: ListOfEnumStringUnconstrained) -> Self {
|
193 + | fn from(value: LengthSetOfPatternStringUnconstrained) -> Self {
|
350 194 | Self::Unconstrained(value)
|
351 195 | }
|
352 196 | }
|
353 - | impl std::convert::TryFrom<ListOfEnumStringUnconstrained>
|
354 - | for crate::constrained::list_of_enum_string_constrained::ListOfEnumStringConstrained
|
197 + | impl std::convert::TryFrom<LengthSetOfPatternStringUnconstrained>
|
198 + | for crate::model::LengthSetOfPatternString
|
355 199 | {
|
356 - | type Error = crate::model::list_of_enum_string::ConstraintViolation;
|
200 + | type Error = crate::model::length_set_of_pattern_string::ConstraintViolation;
|
357 201 | fn try_from(
|
358 - | value: ListOfEnumStringUnconstrained,
|
202 + | value: LengthSetOfPatternStringUnconstrained,
|
359 203 | ) -> std::result::Result<Self, Self::Error> {
|
360 204 | let res: ::std::result::Result<
|
361 - | ::std::vec::Vec<crate::model::EnumString>,
|
362 - | (usize, crate::model::enum_string::ConstraintViolation),
|
205 + | ::std::vec::Vec<crate::model::PatternString>,
|
206 + | (usize, crate::model::pattern_string::ConstraintViolation),
|
363 207 | > = value
|
364 208 | .0
|
365 209 | .into_iter()
|
366 210 | .enumerate()
|
367 211 | .map(|(idx, inner)| {
|
368 212 | inner
|
369 213 | .try_into()
|
370 214 | .map_err(|inner_violation| (idx, inner_violation))
|
371 215 | })
|
372 216 | .collect();
|
373 217 | let inner =
|
374 218 | res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
|
375 - | Ok(Self(inner))
|
376 - | }
|
377 - | }
|
378 - | }
|
379 - | pub(crate) mod map_of_length_list_of_pattern_string_unconstrained {
|
380 - |
|
381 - | #[derive(Debug, Clone)]
|
382 - | pub(crate) struct MapOfLengthListOfPatternStringUnconstrained(pub(crate) std::collections::HashMap<::std::string::String, crate::unconstrained::length_list_of_pattern_string_unconstrained::LengthListOfPatternStringUnconstrained>);
|
383 - |
|
384 - | impl From<MapOfLengthListOfPatternStringUnconstrained> for crate::constrained::MaybeConstrained<crate::constrained::map_of_length_list_of_pattern_string_constrained::MapOfLengthListOfPatternStringConstrained> {
|
385 - | fn from(value: MapOfLengthListOfPatternStringUnconstrained) -> Self {
|
386 - | Self::Unconstrained(value)
|
387 - | }
|
388 - | }
|
389 - | impl std::convert::TryFrom<MapOfLengthListOfPatternStringUnconstrained> for crate::constrained::map_of_length_list_of_pattern_string_constrained::MapOfLengthListOfPatternStringConstrained {
|
390 - | type Error = crate::model::map_of_length_list_of_pattern_string::ConstraintViolation;
|
391 - | fn try_from(value: MapOfLengthListOfPatternStringUnconstrained) -> std::result::Result<Self, Self::Error> {
|
392 - | let res: ::std::result::Result<::std::collections::HashMap<crate::model::PatternString, crate::model::LengthListOfPatternString>, Self::Error> = value.0
|
393 - | .into_iter()
|
394 - | .map(|(k, v)| {
|
395 - | let k: crate::model::PatternString = k.try_into().map_err(Self::Error::Key)?;
|
396 - |
|
397 - | match crate::model::LengthListOfPatternString::try_from(v) {
|
398 - | Ok(v) => Ok((k, v)),
|
399 - | Err(inner_constraint_violation) => Err(Self::Error::Value(k, inner_constraint_violation)),
|
400 - | }
|
401 - | })
|
402 - | .collect();
|
403 - | let hm = res?;
|
404 - | Ok(Self(hm))
|
219 + | Self::try_from(inner)
|
405 220 | }
|
406 221 | }
|
407 222 | }
|
408 - | pub(crate) mod length_list_of_pattern_string_unconstrained {
|
223 + | pub(crate) mod set_of_range_byte_unconstrained {
|
409 224 |
|
410 225 | #[derive(Debug, Clone)]
|
411 - | pub(crate) struct LengthListOfPatternStringUnconstrained(
|
412 - | pub(crate) std::vec::Vec<::std::string::String>,
|
413 - | );
|
226 + | pub(crate) struct SetOfRangeByteUnconstrained(pub(crate) std::vec::Vec<i8>);
|
414 227 |
|
415 - | impl From<LengthListOfPatternStringUnconstrained>
|
416 - | for crate::constrained::MaybeConstrained<crate::model::LengthListOfPatternString>
|
228 + | impl From<SetOfRangeByteUnconstrained>
|
229 + | for crate::constrained::MaybeConstrained<crate::model::SetOfRangeByte>
|
417 230 | {
|
418 - | fn from(value: LengthListOfPatternStringUnconstrained) -> Self {
|
231 + | fn from(value: SetOfRangeByteUnconstrained) -> Self {
|
419 232 | Self::Unconstrained(value)
|
420 233 | }
|
421 234 | }
|
422 - | impl std::convert::TryFrom<LengthListOfPatternStringUnconstrained>
|
423 - | for crate::model::LengthListOfPatternString
|
424 - | {
|
425 - | type Error = crate::model::length_list_of_pattern_string::ConstraintViolation;
|
426 - | fn try_from(
|
427 - | value: LengthListOfPatternStringUnconstrained,
|
428 - | ) -> std::result::Result<Self, Self::Error> {
|
235 + | impl std::convert::TryFrom<SetOfRangeByteUnconstrained> for crate::model::SetOfRangeByte {
|
236 + | type Error = crate::model::set_of_range_byte::ConstraintViolation;
|
237 + | fn try_from(value: SetOfRangeByteUnconstrained) -> std::result::Result<Self, Self::Error> {
|
429 238 | let res: ::std::result::Result<
|
430 - | ::std::vec::Vec<crate::model::PatternString>,
|
431 - | (usize, crate::model::pattern_string::ConstraintViolation),
|
239 + | ::std::vec::Vec<crate::model::RangeByte>,
|
240 + | (usize, crate::model::range_byte::ConstraintViolation),
|
432 241 | > = value
|
433 242 | .0
|
434 243 | .into_iter()
|
435 244 | .enumerate()
|
436 245 | .map(|(idx, inner)| {
|
437 246 | inner
|
438 247 | .try_into()
|
439 248 | .map_err(|inner_violation| (idx, inner_violation))
|
440 249 | })
|
441 250 | .collect();
|
442 251 | let inner =
|
443 252 | res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
|
444 253 | Self::try_from(inner)
|
445 254 | }
|
446 255 | }
|
447 256 | }
|
448 - | pub(crate) mod map_of_set_of_length_string_unconstrained {
|
257 + | pub(crate) mod set_of_range_short_unconstrained {
|
449 258 |
|
450 259 | #[derive(Debug, Clone)]
|
451 - | pub(crate) struct MapOfSetOfLengthStringUnconstrained(pub(crate) std::collections::HashMap<::std::string::String, crate::unconstrained::set_of_length_string_unconstrained::SetOfLengthStringUnconstrained>);
|
260 + | pub(crate) struct SetOfRangeShortUnconstrained(pub(crate) std::vec::Vec<i16>);
|
452 261 |
|
453 - | impl From<MapOfSetOfLengthStringUnconstrained> for crate::constrained::MaybeConstrained<crate::constrained::map_of_set_of_length_string_constrained::MapOfSetOfLengthStringConstrained> {
|
454 - | fn from(value: MapOfSetOfLengthStringUnconstrained) -> Self {
|
455 - | Self::Unconstrained(value)
|
456 - | }
|
457 - | }
|
458 - | impl std::convert::TryFrom<MapOfSetOfLengthStringUnconstrained> for crate::constrained::map_of_set_of_length_string_constrained::MapOfSetOfLengthStringConstrained {
|
459 - | type Error = crate::model::map_of_set_of_length_string::ConstraintViolation;
|
460 - | fn try_from(value: MapOfSetOfLengthStringUnconstrained) -> std::result::Result<Self, Self::Error> {
|
461 - | let res: ::std::result::Result<::std::collections::HashMap<crate::model::LengthString, crate::model::SetOfLengthString>, Self::Error> = value.0
|
462 - | .into_iter()
|
463 - | .map(|(k, v)| {
|
464 - | let k: crate::model::LengthString = k.try_into().map_err(Self::Error::Key)?;
|
465 - |
|
466 - | match crate::model::SetOfLengthString::try_from(v) {
|
467 - | Ok(v) => Ok((k, v)),
|
468 - | Err(inner_constraint_violation) => Err(Self::Error::Value(k, inner_constraint_violation)),
|
469 - | }
|
470 - | })
|
471 - | .collect();
|
472 - | let hm = res?;
|
473 - | Ok(Self(hm))
|
262 + | impl From<SetOfRangeShortUnconstrained>
|
263 + | for crate::constrained::MaybeConstrained<crate::model::SetOfRangeShort>
|
264 + | {
|
265 + | fn from(value: SetOfRangeShortUnconstrained) -> Self {
|
266 + | Self::Unconstrained(value)
|
267 + | }
|
268 + | }
|
269 + | impl std::convert::TryFrom<SetOfRangeShortUnconstrained> for crate::model::SetOfRangeShort {
|
270 + | type Error = crate::model::set_of_range_short::ConstraintViolation;
|
271 + | fn try_from(value: SetOfRangeShortUnconstrained) -> std::result::Result<Self, Self::Error> {
|
272 + | let res: ::std::result::Result<
|
273 + | ::std::vec::Vec<crate::model::RangeShort>,
|
274 + | (usize, crate::model::range_short::ConstraintViolation),
|
275 + | > = value
|
276 + | .0
|
277 + | .into_iter()
|
278 + | .enumerate()
|
279 + | .map(|(idx, inner)| {
|
280 + | inner
|
281 + | .try_into()
|
282 + | .map_err(|inner_violation| (idx, inner_violation))
|
283 + | })
|
284 + | .collect();
|
285 + | let inner =
|
286 + | res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
|
287 + | Self::try_from(inner)
|
474 288 | }
|
475 289 | }
|
476 290 | }
|
477 - | pub(crate) mod set_of_length_string_unconstrained {
|
291 + | pub(crate) mod set_of_range_integer_unconstrained {
|
478 292 |
|
479 293 | #[derive(Debug, Clone)]
|
480 - | pub(crate) struct SetOfLengthStringUnconstrained(
|
481 - | pub(crate) std::vec::Vec<::std::string::String>,
|
482 - | );
|
294 + | pub(crate) struct SetOfRangeIntegerUnconstrained(pub(crate) std::vec::Vec<i32>);
|
483 295 |
|
484 - | impl From<SetOfLengthStringUnconstrained>
|
485 - | for crate::constrained::MaybeConstrained<crate::model::SetOfLengthString>
|
296 + | impl From<SetOfRangeIntegerUnconstrained>
|
297 + | for crate::constrained::MaybeConstrained<crate::model::SetOfRangeInteger>
|
486 298 | {
|
487 - | fn from(value: SetOfLengthStringUnconstrained) -> Self {
|
299 + | fn from(value: SetOfRangeIntegerUnconstrained) -> Self {
|
488 300 | Self::Unconstrained(value)
|
489 301 | }
|
490 302 | }
|
491 - | impl std::convert::TryFrom<SetOfLengthStringUnconstrained> for crate::model::SetOfLengthString {
|
492 - | type Error = crate::model::set_of_length_string::ConstraintViolation;
|
303 + | impl std::convert::TryFrom<SetOfRangeIntegerUnconstrained> for crate::model::SetOfRangeInteger {
|
304 + | type Error = crate::model::set_of_range_integer::ConstraintViolation;
|
493 305 | fn try_from(
|
494 - | value: SetOfLengthStringUnconstrained,
|
306 + | value: SetOfRangeIntegerUnconstrained,
|
495 307 | ) -> std::result::Result<Self, Self::Error> {
|
496 308 | let res: ::std::result::Result<
|
497 - | ::std::vec::Vec<crate::model::LengthString>,
|
498 - | (usize, crate::model::length_string::ConstraintViolation),
|
309 + | ::std::vec::Vec<crate::model::RangeInteger>,
|
310 + | (usize, crate::model::range_integer::ConstraintViolation),
|
499 311 | > = value
|
500 312 | .0
|
501 313 | .into_iter()
|
502 314 | .enumerate()
|
503 315 | .map(|(idx, inner)| {
|
504 316 | inner
|
505 317 | .try_into()
|
506 318 | .map_err(|inner_violation| (idx, inner_violation))
|
507 319 | })
|
508 320 | .collect();
|
509 321 | let inner =
|
510 322 | res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
|
511 323 | Self::try_from(inner)
|
512 324 | }
|
513 325 | }
|
514 326 | }
|
515 - | pub(crate) mod map_of_list_of_length_string_unconstrained {
|
516 - |
|
517 - | #[derive(Debug, Clone)]
|
518 - | pub(crate) struct MapOfListOfLengthStringUnconstrained(pub(crate) std::collections::HashMap<::std::string::String, crate::unconstrained::list_of_length_string_unconstrained::ListOfLengthStringUnconstrained>);
|
519 - |
|
520 - | impl From<MapOfListOfLengthStringUnconstrained> for crate::constrained::MaybeConstrained<crate::constrained::map_of_list_of_length_string_constrained::MapOfListOfLengthStringConstrained> {
|
521 - | fn from(value: MapOfListOfLengthStringUnconstrained) -> Self {
|
522 - | Self::Unconstrained(value)
|
523 - | }
|
524 - | }
|
525 - | impl std::convert::TryFrom<MapOfListOfLengthStringUnconstrained> for crate::constrained::map_of_list_of_length_string_constrained::MapOfListOfLengthStringConstrained {
|
526 - | type Error = crate::model::map_of_list_of_length_string::ConstraintViolation;
|
527 - | fn try_from(value: MapOfListOfLengthStringUnconstrained) -> std::result::Result<Self, Self::Error> {
|
528 - | let res: ::std::result::Result<::std::collections::HashMap<crate::model::LengthString, crate::constrained::list_of_length_string_constrained::ListOfLengthStringConstrained>, Self::Error> = value.0
|
529 - | .into_iter()
|
530 - | .map(|(k, v)| {
|
531 - | let k: crate::model::LengthString = k.try_into().map_err(Self::Error::Key)?;
|
532 - |
|
533 - | match crate::constrained::list_of_length_string_constrained::ListOfLengthStringConstrained::try_from(v) {
|
534 - | Ok(v) => Ok((k, v)),
|
535 - | Err(inner_constraint_violation) => Err(Self::Error::Value(k, inner_constraint_violation)),
|
536 - | }
|
537 - | })
|
538 - | .collect();
|
539 - | let hm = res?;
|
540 - | Ok(Self(hm))
|
541 - | }
|
542 - | }
|
543 - | }
|
544 - | pub(crate) mod list_of_length_string_unconstrained {
|
327 + | pub(crate) mod set_of_range_long_unconstrained {
|
545 328 |
|
546 329 | #[derive(Debug, Clone)]
|
547 - | pub(crate) struct ListOfLengthStringUnconstrained(
|
548 - | pub(crate) std::vec::Vec<::std::string::String>,
|
549 - | );
|
330 + | pub(crate) struct SetOfRangeLongUnconstrained(pub(crate) std::vec::Vec<i64>);
|
550 331 |
|
551 - | impl From<ListOfLengthStringUnconstrained>
|
552 - | for crate::constrained::MaybeConstrained<
|
553 - | crate::constrained::list_of_length_string_constrained::ListOfLengthStringConstrained,
|
554 - | >
|
332 + | impl From<SetOfRangeLongUnconstrained>
|
333 + | for crate::constrained::MaybeConstrained<crate::model::SetOfRangeLong>
|
555 334 | {
|
556 - | fn from(value: ListOfLengthStringUnconstrained) -> Self {
|
335 + | fn from(value: SetOfRangeLongUnconstrained) -> Self {
|
557 336 | Self::Unconstrained(value)
|
558 337 | }
|
559 338 | }
|
560 - | impl std::convert::TryFrom<ListOfLengthStringUnconstrained>
|
561 - | for crate::constrained::list_of_length_string_constrained::ListOfLengthStringConstrained
|
562 - | {
|
563 - | type Error = crate::model::list_of_length_string::ConstraintViolation;
|
564 - | fn try_from(
|
565 - | value: ListOfLengthStringUnconstrained,
|
566 - | ) -> std::result::Result<Self, Self::Error> {
|
339 + | impl std::convert::TryFrom<SetOfRangeLongUnconstrained> for crate::model::SetOfRangeLong {
|
340 + | type Error = crate::model::set_of_range_long::ConstraintViolation;
|
341 + | fn try_from(value: SetOfRangeLongUnconstrained) -> std::result::Result<Self, Self::Error> {
|
567 342 | let res: ::std::result::Result<
|
568 - | ::std::vec::Vec<crate::model::LengthString>,
|
569 - | (usize, crate::model::length_string::ConstraintViolation),
|
343 + | ::std::vec::Vec<crate::model::RangeLong>,
|
344 + | (usize, crate::model::range_long::ConstraintViolation),
|
570 345 | > = value
|
571 346 | .0
|
572 347 | .into_iter()
|
573 348 | .enumerate()
|
574 349 | .map(|(idx, inner)| {
|
575 350 | inner
|
576 351 | .try_into()
|
577 352 | .map_err(|inner_violation| (idx, inner_violation))
|
578 353 | })
|
579 354 | .collect();
|
580 355 | let inner =
|
581 356 | res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
|
582 - | Ok(Self(inner))
|
357 + | Self::try_from(inner)
|
583 358 | }
|
584 359 | }
|
585 360 | }
|
586 - | pub(crate) mod map_of_length_string_unconstrained {
|
361 + | pub(crate) mod list_of_range_byte_unconstrained {
|
587 362 |
|
588 363 | #[derive(Debug, Clone)]
|
589 - | pub(crate) struct MapOfLengthStringUnconstrained(
|
590 - | pub(crate) std::collections::HashMap<::std::string::String, ::std::string::String>,
|
591 - | );
|
364 + | pub(crate) struct ListOfRangeByteUnconstrained(pub(crate) std::vec::Vec<i8>);
|
592 365 |
|
593 - | impl From<MapOfLengthStringUnconstrained>
|
366 + | impl From<ListOfRangeByteUnconstrained>
|
594 367 | for crate::constrained::MaybeConstrained<
|
595 - | crate::constrained::map_of_length_string_constrained::MapOfLengthStringConstrained,
|
368 + | crate::constrained::list_of_range_byte_constrained::ListOfRangeByteConstrained,
|
596 369 | >
|
597 370 | {
|
598 - | fn from(value: MapOfLengthStringUnconstrained) -> Self {
|
371 + | fn from(value: ListOfRangeByteUnconstrained) -> Self {
|
599 372 | Self::Unconstrained(value)
|
600 373 | }
|
601 374 | }
|
602 - | impl std::convert::TryFrom<MapOfLengthStringUnconstrained>
|
603 - | for crate::constrained::map_of_length_string_constrained::MapOfLengthStringConstrained
|
375 + | impl std::convert::TryFrom<ListOfRangeByteUnconstrained>
|
376 + | for crate::constrained::list_of_range_byte_constrained::ListOfRangeByteConstrained
|
604 377 | {
|
605 - | type Error = crate::model::map_of_length_string::ConstraintViolation;
|
606 - | fn try_from(
|
607 - | value: MapOfLengthStringUnconstrained,
|
608 - | ) -> std::result::Result<Self, Self::Error> {
|
378 + | type Error = crate::model::list_of_range_byte::ConstraintViolation;
|
379 + | fn try_from(value: ListOfRangeByteUnconstrained) -> std::result::Result<Self, Self::Error> {
|
609 380 | let res: ::std::result::Result<
|
610 - | ::std::collections::HashMap<crate::model::LengthString, crate::model::LengthString>,
|
611 - | Self::Error,
|
381 + | ::std::vec::Vec<crate::model::RangeByte>,
|
382 + | (usize, crate::model::range_byte::ConstraintViolation),
|
612 383 | > = value
|
613 384 | .0
|
614 385 | .into_iter()
|
615 - | .map(|(k, v)| {
|
616 - | let k: crate::model::LengthString = k.try_into().map_err(Self::Error::Key)?;
|
617 - |
|
618 - | match crate::model::LengthString::try_from(v) {
|
619 - | Ok(v) => Ok((k, v)),
|
620 - | Err(inner_constraint_violation) => {
|
621 - | Err(Self::Error::Value(k, inner_constraint_violation))
|
622 - | }
|
623 - | }
|
386 + | .enumerate()
|
387 + | .map(|(idx, inner)| {
|
388 + | inner
|
389 + | .try_into()
|
390 + | .map_err(|inner_violation| (idx, inner_violation))
|
624 391 | })
|
625 392 | .collect();
|
626 - | let hm = res?;
|
627 - | Ok(Self(hm))
|
393 + | let inner =
|
394 + | res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
|
395 + | Ok(Self(inner))
|
628 396 | }
|
629 397 | }
|
630 398 | }
|
631 - | pub(crate) mod recursive_list_unconstrained {
|
399 + | pub(crate) mod list_of_range_short_unconstrained {
|
632 400 |
|
633 401 | #[derive(Debug, Clone)]
|
634 - | pub(crate) struct RecursiveListUnconstrained(
|
635 - | pub(crate) std::vec::Vec<crate::model::recursive_shapes_input_output_nested1::Builder>,
|
636 - | );
|
402 + | pub(crate) struct ListOfRangeShortUnconstrained(pub(crate) std::vec::Vec<i16>);
|
637 403 |
|
638 - | impl From<RecursiveListUnconstrained>
|
404 + | impl From<ListOfRangeShortUnconstrained>
|
639 405 | for crate::constrained::MaybeConstrained<
|
640 - | crate::constrained::recursive_list_constrained::RecursiveListConstrained,
|
406 + | crate::constrained::list_of_range_short_constrained::ListOfRangeShortConstrained,
|
641 407 | >
|
642 408 | {
|
643 - | fn from(value: RecursiveListUnconstrained) -> Self {
|
409 + | fn from(value: ListOfRangeShortUnconstrained) -> Self {
|
644 410 | Self::Unconstrained(value)
|
645 411 | }
|
646 412 | }
|
647 - | impl std::convert::TryFrom<RecursiveListUnconstrained>
|
648 - | for crate::constrained::recursive_list_constrained::RecursiveListConstrained
|
413 + | impl std::convert::TryFrom<ListOfRangeShortUnconstrained>
|
414 + | for crate::constrained::list_of_range_short_constrained::ListOfRangeShortConstrained
|
649 415 | {
|
650 - | type Error = crate::model::recursive_list::ConstraintViolation;
|
651 - | fn try_from(value: RecursiveListUnconstrained) -> std::result::Result<Self, Self::Error> {
|
416 + | type Error = crate::model::list_of_range_short::ConstraintViolation;
|
417 + | fn try_from(
|
418 + | value: ListOfRangeShortUnconstrained,
|
419 + | ) -> std::result::Result<Self, Self::Error> {
|
652 420 | let res: ::std::result::Result<
|
653 - | ::std::vec::Vec<crate::model::RecursiveShapesInputOutputNested1>,
|
654 - | (
|
655 - | usize,
|
656 - | crate::model::recursive_shapes_input_output_nested1::ConstraintViolation,
|
657 - | ),
|
421 + | ::std::vec::Vec<crate::model::RangeShort>,
|
422 + | (usize, crate::model::range_short::ConstraintViolation),
|
658 423 | > = value
|
659 424 | .0
|
660 425 | .into_iter()
|
661 426 | .enumerate()
|
662 427 | .map(|(idx, inner)| {
|
663 428 | inner
|
664 429 | .try_into()
|
665 430 | .map_err(|inner_violation| (idx, inner_violation))
|
666 431 | })
|
667 432 | .collect();
|
668 433 | let inner =
|
669 434 | res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
|
670 435 | Ok(Self(inner))
|
671 436 | }
|
672 437 | }
|
673 438 | }
|
674 - | pub(crate) mod length_set_of_pattern_string_unconstrained {
|
439 + | pub(crate) mod list_of_range_integer_unconstrained {
|
675 440 |
|
676 441 | #[derive(Debug, Clone)]
|
677 - | pub(crate) struct LengthSetOfPatternStringUnconstrained(
|
678 - | pub(crate) std::vec::Vec<::std::string::String>,
|
679 - | );
|
442 + | pub(crate) struct ListOfRangeIntegerUnconstrained(pub(crate) std::vec::Vec<i32>);
|
680 443 |
|
681 - | impl From<LengthSetOfPatternStringUnconstrained>
|
682 - | for crate::constrained::MaybeConstrained<crate::model::LengthSetOfPatternString>
|
444 + | impl From<ListOfRangeIntegerUnconstrained>
|
445 + | for crate::constrained::MaybeConstrained<
|
446 + | crate::constrained::list_of_range_integer_constrained::ListOfRangeIntegerConstrained,
|
447 + | >
|
683 448 | {
|
684 - | fn from(value: LengthSetOfPatternStringUnconstrained) -> Self {
|
449 + | fn from(value: ListOfRangeIntegerUnconstrained) -> Self {
|
685 450 | Self::Unconstrained(value)
|
686 451 | }
|
687 452 | }
|
688 - | impl std::convert::TryFrom<LengthSetOfPatternStringUnconstrained>
|
689 - | for crate::model::LengthSetOfPatternString
|
453 + | impl std::convert::TryFrom<ListOfRangeIntegerUnconstrained>
|
454 + | for crate::constrained::list_of_range_integer_constrained::ListOfRangeIntegerConstrained
|
690 455 | {
|
691 - | type Error = crate::model::length_set_of_pattern_string::ConstraintViolation;
|
456 + | type Error = crate::model::list_of_range_integer::ConstraintViolation;
|
692 457 | fn try_from(
|
693 - | value: LengthSetOfPatternStringUnconstrained,
|
458 + | value: ListOfRangeIntegerUnconstrained,
|
694 459 | ) -> std::result::Result<Self, Self::Error> {
|
695 460 | let res: ::std::result::Result<
|
696 - | ::std::vec::Vec<crate::model::PatternString>,
|
697 - | (usize, crate::model::pattern_string::ConstraintViolation),
|
461 + | ::std::vec::Vec<crate::model::RangeInteger>,
|
462 + | (usize, crate::model::range_integer::ConstraintViolation),
|
698 463 | > = value
|
699 464 | .0
|
700 465 | .into_iter()
|
701 466 | .enumerate()
|
702 467 | .map(|(idx, inner)| {
|
703 468 | inner
|
704 469 | .try_into()
|
705 470 | .map_err(|inner_violation| (idx, inner_violation))
|
706 471 | })
|
707 472 | .collect();
|
708 473 | let inner =
|
709 474 | res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
|
710 - | Self::try_from(inner)
|
475 + | Ok(Self(inner))
|
711 476 | }
|
712 477 | }
|
713 478 | }
|
714 - | pub(crate) mod set_of_length_pattern_string_unconstrained {
|
479 + | pub(crate) mod list_of_range_long_unconstrained {
|
715 480 |
|
716 481 | #[derive(Debug, Clone)]
|
717 - | pub(crate) struct SetOfLengthPatternStringUnconstrained(
|
718 - | pub(crate) std::vec::Vec<::std::string::String>,
|
719 - | );
|
482 + | pub(crate) struct ListOfRangeLongUnconstrained(pub(crate) std::vec::Vec<i64>);
|
720 483 |
|
721 - | impl From<SetOfLengthPatternStringUnconstrained>
|
722 - | for crate::constrained::MaybeConstrained<crate::model::SetOfLengthPatternString>
|
484 + | impl From<ListOfRangeLongUnconstrained>
|
485 + | for crate::constrained::MaybeConstrained<
|
486 + | crate::constrained::list_of_range_long_constrained::ListOfRangeLongConstrained,
|
487 + | >
|
723 488 | {
|
724 - | fn from(value: SetOfLengthPatternStringUnconstrained) -> Self {
|
489 + | fn from(value: ListOfRangeLongUnconstrained) -> Self {
|
725 490 | Self::Unconstrained(value)
|
726 491 | }
|
727 492 | }
|
728 - | impl std::convert::TryFrom<SetOfLengthPatternStringUnconstrained>
|
729 - | for crate::model::SetOfLengthPatternString
|
493 + | impl std::convert::TryFrom<ListOfRangeLongUnconstrained>
|
494 + | for crate::constrained::list_of_range_long_constrained::ListOfRangeLongConstrained
|
730 495 | {
|
731 - | type Error = crate::model::set_of_length_pattern_string::ConstraintViolation;
|
732 - | fn try_from(
|
733 - | value: SetOfLengthPatternStringUnconstrained,
|
734 - | ) -> std::result::Result<Self, Self::Error> {
|
496 + | type Error = crate::model::list_of_range_long::ConstraintViolation;
|
497 + | fn try_from(value: ListOfRangeLongUnconstrained) -> std::result::Result<Self, Self::Error> {
|
735 498 | let res: ::std::result::Result<
|
736 - | ::std::vec::Vec<crate::model::LengthPatternString>,
|
737 - | (
|
738 - | usize,
|
739 - | crate::model::length_pattern_string::ConstraintViolation,
|
740 - | ),
|
499 + | ::std::vec::Vec<crate::model::RangeLong>,
|
500 + | (usize, crate::model::range_long::ConstraintViolation),
|
741 501 | > = value
|
742 502 | .0
|
743 503 | .into_iter()
|
744 504 | .enumerate()
|
745 505 | .map(|(idx, inner)| {
|
746 506 | inner
|
747 507 | .try_into()
|
748 508 | .map_err(|inner_violation| (idx, inner_violation))
|
749 509 | })
|
750 510 | .collect();
|
751 511 | let inner =
|
752 512 | res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
|
753 - | Self::try_from(inner)
|
513 + | Ok(Self(inner))
|
754 514 | }
|
755 515 | }
|
756 516 | }
|
757 - | pub(crate) mod set_of_pattern_string_unconstrained {
|
517 + | pub(crate) mod list_of_enum_string_unconstrained {
|
758 518 |
|
759 519 | #[derive(Debug, Clone)]
|
760 - | pub(crate) struct SetOfPatternStringUnconstrained(
|
520 + | pub(crate) struct ListOfEnumStringUnconstrained(
|
761 521 | pub(crate) std::vec::Vec<::std::string::String>,
|
762 522 | );
|
763 523 |
|
764 - | impl From<SetOfPatternStringUnconstrained>
|
765 - | for crate::constrained::MaybeConstrained<crate::model::SetOfPatternString>
|
524 + | impl From<ListOfEnumStringUnconstrained>
|
525 + | for crate::constrained::MaybeConstrained<
|
526 + | crate::constrained::list_of_enum_string_constrained::ListOfEnumStringConstrained,
|
527 + | >
|
766 528 | {
|
767 - | fn from(value: SetOfPatternStringUnconstrained) -> Self {
|
529 + | fn from(value: ListOfEnumStringUnconstrained) -> Self {
|
768 530 | Self::Unconstrained(value)
|
769 531 | }
|
770 532 | }
|
771 - | impl std::convert::TryFrom<SetOfPatternStringUnconstrained> for crate::model::SetOfPatternString {
|
772 - | type Error = crate::model::set_of_pattern_string::ConstraintViolation;
|
533 + | impl std::convert::TryFrom<ListOfEnumStringUnconstrained>
|
534 + | for crate::constrained::list_of_enum_string_constrained::ListOfEnumStringConstrained
|
535 + | {
|
536 + | type Error = crate::model::list_of_enum_string::ConstraintViolation;
|
773 537 | fn try_from(
|
774 - | value: SetOfPatternStringUnconstrained,
|
538 + | value: ListOfEnumStringUnconstrained,
|
775 539 | ) -> std::result::Result<Self, Self::Error> {
|
776 540 | let res: ::std::result::Result<
|
777 - | ::std::vec::Vec<crate::model::PatternString>,
|
778 - | (usize, crate::model::pattern_string::ConstraintViolation),
|
541 + | ::std::vec::Vec<crate::model::EnumString>,
|
542 + | (usize, crate::model::enum_string::ConstraintViolation),
|
779 543 | > = value
|
780 544 | .0
|
781 545 | .into_iter()
|
782 546 | .enumerate()
|
783 547 | .map(|(idx, inner)| {
|
784 548 | inner
|
785 549 | .try_into()
|
786 550 | .map_err(|inner_violation| (idx, inner_violation))
|
787 551 | })
|
788 552 | .collect();
|
789 553 | let inner =
|
790 554 | res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
|
791 - | Self::try_from(inner)
|
555 + | Ok(Self(inner))
|
792 556 | }
|
793 557 | }
|
794 558 | }
|
795 - | pub(crate) mod map_of_range_byte_unconstrained {
|
559 + | pub(crate) mod recursive_list_unconstrained {
|
796 560 |
|
797 561 | #[derive(Debug, Clone)]
|
798 - | pub(crate) struct MapOfRangeByteUnconstrained(
|
799 - | pub(crate) std::collections::HashMap<::std::string::String, i8>,
|
562 + | pub(crate) struct RecursiveListUnconstrained(
|
563 + | pub(crate) std::vec::Vec<crate::model::recursive_shapes_input_output_nested1::Builder>,
|
800 564 | );
|
801 565 |
|
802 - | impl From<MapOfRangeByteUnconstrained>
|
566 + | impl From<RecursiveListUnconstrained>
|
803 567 | for crate::constrained::MaybeConstrained<
|
804 - | crate::constrained::map_of_range_byte_constrained::MapOfRangeByteConstrained,
|
568 + | crate::constrained::recursive_list_constrained::RecursiveListConstrained,
|
805 569 | >
|
806 570 | {
|
807 - | fn from(value: MapOfRangeByteUnconstrained) -> Self {
|
571 + | fn from(value: RecursiveListUnconstrained) -> Self {
|
808 572 | Self::Unconstrained(value)
|
809 573 | }
|
810 574 | }
|
811 - | impl std::convert::TryFrom<MapOfRangeByteUnconstrained>
|
812 - | for crate::constrained::map_of_range_byte_constrained::MapOfRangeByteConstrained
|
575 + | impl std::convert::TryFrom<RecursiveListUnconstrained>
|
576 + | for crate::constrained::recursive_list_constrained::RecursiveListConstrained
|
813 577 | {
|
814 - | type Error = crate::model::map_of_range_byte::ConstraintViolation;
|
815 - | fn try_from(value: MapOfRangeByteUnconstrained) -> std::result::Result<Self, Self::Error> {
|
578 + | type Error = crate::model::recursive_list::ConstraintViolation;
|
579 + | fn try_from(value: RecursiveListUnconstrained) -> std::result::Result<Self, Self::Error> {
|
816 580 | let res: ::std::result::Result<
|
817 - | ::std::collections::HashMap<::std::string::String, crate::model::RangeByte>,
|
581 + | ::std::vec::Vec<crate::model::RecursiveShapesInputOutputNested1>,
|
582 + | (
|
583 + | usize,
|
584 + | crate::model::recursive_shapes_input_output_nested1::ConstraintViolation,
|
585 + | ),
|
586 + | > = value
|
587 + | .0
|
588 + | .into_iter()
|
589 + | .enumerate()
|
590 + | .map(|(idx, inner)| {
|
591 + | inner
|
592 + | .try_into()
|
593 + | .map_err(|inner_violation| (idx, inner_violation))
|
594 + | })
|
595 + | .collect();
|
596 + | let inner =
|
597 + | res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
|
598 + | Ok(Self(inner))
|
599 + | }
|
600 + | }
|
601 + | }
|
602 + | pub(crate) mod con_b_map_unconstrained {
|
603 + |
|
604 + | #[derive(Debug, Clone)]
|
605 + | pub(crate) struct ConBMapUnconstrained(
|
606 + | pub(crate) std::collections::HashMap<::std::string::String, ::std::string::String>,
|
607 + | );
|
608 + |
|
609 + | impl From<ConBMapUnconstrained> for crate::constrained::MaybeConstrained<crate::model::ConBMap> {
|
610 + | fn from(value: ConBMapUnconstrained) -> Self {
|
611 + | Self::Unconstrained(value)
|
612 + | }
|
613 + | }
|
614 + | impl std::convert::TryFrom<ConBMapUnconstrained> for crate::model::ConBMap {
|
615 + | type Error = crate::model::con_b_map::ConstraintViolation;
|
616 + | fn try_from(value: ConBMapUnconstrained) -> std::result::Result<Self, Self::Error> {
|
617 + | let res: ::std::result::Result<
|
618 + | ::std::collections::HashMap<::std::string::String, crate::model::LengthString>,
|
818 619 | Self::Error,
|
819 620 | > = value
|
820 621 | .0
|
821 622 | .into_iter()
|
822 - | .map(|(k, v)| match crate::model::RangeByte::try_from(v) {
|
623 + | .map(|(k, v)| match crate::model::LengthString::try_from(v) {
|
823 624 | Ok(v) => Ok((k, v)),
|
824 625 | Err(inner_constraint_violation) => {
|
825 626 | Err(Self::Error::Value(k, inner_constraint_violation))
|
826 627 | }
|
827 628 | })
|
828 629 | .collect();
|
829 630 | let hm = res?;
|
631 + | Self::try_from(hm)
|
632 + | }
|
633 + | }
|
634 + | }
|
635 + | pub(crate) mod map_of_list_of_length_string_unconstrained {
|
636 + |
|
637 + | #[derive(Debug, Clone)]
|
638 + | pub(crate) struct MapOfListOfLengthStringUnconstrained(pub(crate) std::collections::HashMap<::std::string::String, crate::unconstrained::list_of_length_string_unconstrained::ListOfLengthStringUnconstrained>);
|
639 + |
|
640 + | impl From<MapOfListOfLengthStringUnconstrained> for crate::constrained::MaybeConstrained<crate::constrained::map_of_list_of_length_string_constrained::MapOfListOfLengthStringConstrained> {
|
641 + | fn from(value: MapOfListOfLengthStringUnconstrained) -> Self {
|
642 + | Self::Unconstrained(value)
|
643 + | }
|
644 + | }
|
645 + | impl std::convert::TryFrom<MapOfListOfLengthStringUnconstrained> for crate::constrained::map_of_list_of_length_string_constrained::MapOfListOfLengthStringConstrained {
|
646 + | type Error = crate::model::map_of_list_of_length_string::ConstraintViolation;
|
647 + | fn try_from(value: MapOfListOfLengthStringUnconstrained) -> std::result::Result<Self, Self::Error> {
|
648 + | let res: ::std::result::Result<::std::collections::HashMap<crate::model::LengthString, crate::constrained::list_of_length_string_constrained::ListOfLengthStringConstrained>, Self::Error> = value.0
|
649 + | .into_iter()
|
650 + | .map(|(k, v)| {
|
651 + | let k: crate::model::LengthString = k.try_into().map_err(Self::Error::Key)?;
|
652 + |
|
653 + | match crate::constrained::list_of_length_string_constrained::ListOfLengthStringConstrained::try_from(v) {
|
654 + | Ok(v) => Ok((k, v)),
|
655 + | Err(inner_constraint_violation) => Err(Self::Error::Value(k, inner_constraint_violation)),
|
656 + | }
|
657 + | })
|
658 + | .collect();
|
659 + | let hm = res?;
|
830 660 | Ok(Self(hm))
|
831 661 | }
|
832 662 | }
|
833 663 | }
|
834 - | pub(crate) mod set_of_range_byte_unconstrained {
|
664 + | pub(crate) mod map_of_set_of_length_string_unconstrained {
|
835 665 |
|
836 666 | #[derive(Debug, Clone)]
|
837 - | pub(crate) struct SetOfRangeByteUnconstrained(pub(crate) std::vec::Vec<i8>);
|
667 + | pub(crate) struct MapOfSetOfLengthStringUnconstrained(pub(crate) std::collections::HashMap<::std::string::String, crate::unconstrained::set_of_length_string_unconstrained::SetOfLengthStringUnconstrained>);
|
838 668 |
|
839 - | impl From<SetOfRangeByteUnconstrained>
|
840 - | for crate::constrained::MaybeConstrained<crate::model::SetOfRangeByte>
|
669 + | impl From<MapOfSetOfLengthStringUnconstrained> for crate::constrained::MaybeConstrained<crate::constrained::map_of_set_of_length_string_constrained::MapOfSetOfLengthStringConstrained> {
|
670 + | fn from(value: MapOfSetOfLengthStringUnconstrained) -> Self {
|
671 + | Self::Unconstrained(value)
|
672 + | }
|
673 + | }
|
674 + | impl std::convert::TryFrom<MapOfSetOfLengthStringUnconstrained> for crate::constrained::map_of_set_of_length_string_constrained::MapOfSetOfLengthStringConstrained {
|
675 + | type Error = crate::model::map_of_set_of_length_string::ConstraintViolation;
|
676 + | fn try_from(value: MapOfSetOfLengthStringUnconstrained) -> std::result::Result<Self, Self::Error> {
|
677 + | let res: ::std::result::Result<::std::collections::HashMap<crate::model::LengthString, crate::model::SetOfLengthString>, Self::Error> = value.0
|
678 + | .into_iter()
|
679 + | .map(|(k, v)| {
|
680 + | let k: crate::model::LengthString = k.try_into().map_err(Self::Error::Key)?;
|
681 + |
|
682 + | match crate::model::SetOfLengthString::try_from(v) {
|
683 + | Ok(v) => Ok((k, v)),
|
684 + | Err(inner_constraint_violation) => Err(Self::Error::Value(k, inner_constraint_violation)),
|
685 + | }
|
686 + | })
|
687 + | .collect();
|
688 + | let hm = res?;
|
689 + | Ok(Self(hm))
|
690 + | }
|
691 + | }
|
692 + | }
|
693 + | pub(crate) mod map_of_length_list_of_pattern_string_unconstrained {
|
694 + |
|
695 + | #[derive(Debug, Clone)]
|
696 + | pub(crate) struct MapOfLengthListOfPatternStringUnconstrained(pub(crate) std::collections::HashMap<::std::string::String, crate::unconstrained::length_list_of_pattern_string_unconstrained::LengthListOfPatternStringUnconstrained>);
|
697 + |
|
698 + | impl From<MapOfLengthListOfPatternStringUnconstrained> for crate::constrained::MaybeConstrained<crate::constrained::map_of_length_list_of_pattern_string_constrained::MapOfLengthListOfPatternStringConstrained> {
|
699 + | fn from(value: MapOfLengthListOfPatternStringUnconstrained) -> Self {
|
700 + | Self::Unconstrained(value)
|
701 + | }
|
702 + | }
|
703 + | impl std::convert::TryFrom<MapOfLengthListOfPatternStringUnconstrained> for crate::constrained::map_of_length_list_of_pattern_string_constrained::MapOfLengthListOfPatternStringConstrained {
|
704 + | type Error = crate::model::map_of_length_list_of_pattern_string::ConstraintViolation;
|
705 + | fn try_from(value: MapOfLengthListOfPatternStringUnconstrained) -> std::result::Result<Self, Self::Error> {
|
706 + | let res: ::std::result::Result<::std::collections::HashMap<crate::model::PatternString, crate::model::LengthListOfPatternString>, Self::Error> = value.0
|
707 + | .into_iter()
|
708 + | .map(|(k, v)| {
|
709 + | let k: crate::model::PatternString = k.try_into().map_err(Self::Error::Key)?;
|
710 + |
|
711 + | match crate::model::LengthListOfPatternString::try_from(v) {
|
712 + | Ok(v) => Ok((k, v)),
|
713 + | Err(inner_constraint_violation) => Err(Self::Error::Value(k, inner_constraint_violation)),
|
714 + | }
|
715 + | })
|
716 + | .collect();
|
717 + | let hm = res?;
|
718 + | Ok(Self(hm))
|
719 + | }
|
720 + | }
|
721 + | }
|
722 + | pub(crate) mod map_of_list_of_enum_string_unconstrained {
|
723 + |
|
724 + | #[derive(Debug, Clone)]
|
725 + | pub(crate) struct MapOfListOfEnumStringUnconstrained(
|
726 + | pub(crate) std::collections::HashMap<
|
727 + | ::std::string::String,
|
728 + | crate::unconstrained::list_of_enum_string_unconstrained::ListOfEnumStringUnconstrained,
|
729 + | >,
|
730 + | );
|
731 + |
|
732 + | impl From<MapOfListOfEnumStringUnconstrained> for crate::constrained::MaybeConstrained<crate::constrained::map_of_list_of_enum_string_constrained::MapOfListOfEnumStringConstrained> {
|
733 + | fn from(value: MapOfListOfEnumStringUnconstrained) -> Self {
|
734 + | Self::Unconstrained(value)
|
735 + | }
|
736 + | }
|
737 + | impl std::convert::TryFrom<MapOfListOfEnumStringUnconstrained> for crate::constrained::map_of_list_of_enum_string_constrained::MapOfListOfEnumStringConstrained {
|
738 + | type Error = crate::model::map_of_list_of_enum_string::ConstraintViolation;
|
739 + | fn try_from(value: MapOfListOfEnumStringUnconstrained) -> std::result::Result<Self, Self::Error> {
|
740 + | let res: ::std::result::Result<::std::collections::HashMap<crate::model::EnumString, crate::constrained::list_of_enum_string_constrained::ListOfEnumStringConstrained>, Self::Error> = value.0
|
741 + | .into_iter()
|
742 + | .map(|(k, v)| {
|
743 + | let k: crate::model::EnumString = k.try_into().map_err(Self::Error::Key)?;
|
744 + |
|
745 + | match crate::constrained::list_of_enum_string_constrained::ListOfEnumStringConstrained::try_from(v) {
|
746 + | Ok(v) => Ok((k, v)),
|
747 + | Err(inner_constraint_violation) => Err(Self::Error::Value(k, inner_constraint_violation)),
|
748 + | }
|
749 + | })
|
750 + | .collect();
|
751 + | let hm = res?;
|
752 + | Ok(Self(hm))
|
753 + | }
|
754 + | }
|
755 + | }
|
756 + | pub(crate) mod map_of_pattern_string_unconstrained {
|
757 + |
|
758 + | #[derive(Debug, Clone)]
|
759 + | pub(crate) struct MapOfPatternStringUnconstrained(
|
760 + | pub(crate) std::collections::HashMap<::std::string::String, ::std::string::String>,
|
761 + | );
|
762 + |
|
763 + | impl From<MapOfPatternStringUnconstrained>
|
764 + | for crate::constrained::MaybeConstrained<
|
765 + | crate::constrained::map_of_pattern_string_constrained::MapOfPatternStringConstrained,
|
766 + | >
|
841 767 | {
|
842 - | fn from(value: SetOfRangeByteUnconstrained) -> Self {
|
768 + | fn from(value: MapOfPatternStringUnconstrained) -> Self {
|
843 769 | Self::Unconstrained(value)
|
844 770 | }
|
845 771 | }
|
846 - | impl std::convert::TryFrom<SetOfRangeByteUnconstrained> for crate::model::SetOfRangeByte {
|
847 - | type Error = crate::model::set_of_range_byte::ConstraintViolation;
|
848 - | fn try_from(value: SetOfRangeByteUnconstrained) -> std::result::Result<Self, Self::Error> {
|
772 + | impl std::convert::TryFrom<MapOfPatternStringUnconstrained>
|
773 + | for crate::constrained::map_of_pattern_string_constrained::MapOfPatternStringConstrained
|
774 + | {
|
775 + | type Error = crate::model::map_of_pattern_string::ConstraintViolation;
|
776 + | fn try_from(
|
777 + | value: MapOfPatternStringUnconstrained,
|
778 + | ) -> std::result::Result<Self, Self::Error> {
|
849 779 | let res: ::std::result::Result<
|
850 - | ::std::vec::Vec<crate::model::RangeByte>,
|
851 - | (usize, crate::model::range_byte::ConstraintViolation),
|
780 + | ::std::collections::HashMap<
|
781 + | crate::model::PatternString,
|
782 + | crate::model::PatternString,
|
783 + | >,
|
784 + | Self::Error,
|
785 + | > = value
|
786 + | .0
|
787 + | .into_iter()
|
788 + | .map(|(k, v)| {
|
789 + | let k: crate::model::PatternString = k.try_into().map_err(Self::Error::Key)?;
|
790 + |
|
791 + | match crate::model::PatternString::try_from(v) {
|
792 + | Ok(v) => Ok((k, v)),
|
793 + | Err(inner_constraint_violation) => {
|
794 + | Err(Self::Error::Value(k, inner_constraint_violation))
|
795 + | }
|
796 + | }
|
797 + | })
|
798 + | .collect();
|
799 + | let hm = res?;
|
800 + | Ok(Self(hm))
|
801 + | }
|
802 + | }
|
803 + | }
|
804 + | pub(crate) mod map_of_list_of_pattern_string_unconstrained {
|
805 + |
|
806 + | #[derive(Debug, Clone)]
|
807 + | pub(crate) struct MapOfListOfPatternStringUnconstrained(pub(crate) std::collections::HashMap<::std::string::String, crate::unconstrained::list_of_pattern_string_unconstrained::ListOfPatternStringUnconstrained>);
|
808 + |
|
809 + | impl From<MapOfListOfPatternStringUnconstrained> for crate::constrained::MaybeConstrained<crate::constrained::map_of_list_of_pattern_string_constrained::MapOfListOfPatternStringConstrained> {
|
810 + | fn from(value: MapOfListOfPatternStringUnconstrained) -> Self {
|
811 + | Self::Unconstrained(value)
|
812 + | }
|
813 + | }
|
814 + | impl std::convert::TryFrom<MapOfListOfPatternStringUnconstrained> for crate::constrained::map_of_list_of_pattern_string_constrained::MapOfListOfPatternStringConstrained {
|
815 + | type Error = crate::model::map_of_list_of_pattern_string::ConstraintViolation;
|
816 + | fn try_from(value: MapOfListOfPatternStringUnconstrained) -> std::result::Result<Self, Self::Error> {
|
817 + | let res: ::std::result::Result<::std::collections::HashMap<crate::model::PatternString, crate::constrained::list_of_pattern_string_constrained::ListOfPatternStringConstrained>, Self::Error> = value.0
|
818 + | .into_iter()
|
819 + | .map(|(k, v)| {
|
820 + | let k: crate::model::PatternString = k.try_into().map_err(Self::Error::Key)?;
|
821 + |
|
822 + | match crate::constrained::list_of_pattern_string_constrained::ListOfPatternStringConstrained::try_from(v) {
|
823 + | Ok(v) => Ok((k, v)),
|
824 + | Err(inner_constraint_violation) => Err(Self::Error::Value(k, inner_constraint_violation)),
|
825 + | }
|
826 + | })
|
827 + | .collect();
|
828 + | let hm = res?;
|
829 + | Ok(Self(hm))
|
830 + | }
|
831 + | }
|
832 + | }
|
833 + | pub(crate) mod map_of_length_pattern_string_unconstrained {
|
834 + |
|
835 + | #[derive(Debug, Clone)]
|
836 + | pub(crate) struct MapOfLengthPatternStringUnconstrained(
|
837 + | pub(crate) std::collections::HashMap<::std::string::String, ::std::string::String>,
|
838 + | );
|
839 + |
|
840 + | impl From<MapOfLengthPatternStringUnconstrained> for crate::constrained::MaybeConstrained<crate::constrained::map_of_length_pattern_string_constrained::MapOfLengthPatternStringConstrained> {
|
841 + | fn from(value: MapOfLengthPatternStringUnconstrained) -> Self {
|
842 + | Self::Unconstrained(value)
|
843 + | }
|
844 + | }
|
845 + | impl std::convert::TryFrom<MapOfLengthPatternStringUnconstrained> for crate::constrained::map_of_length_pattern_string_constrained::MapOfLengthPatternStringConstrained {
|
846 + | type Error = crate::model::map_of_length_pattern_string::ConstraintViolation;
|
847 + | fn try_from(value: MapOfLengthPatternStringUnconstrained) -> std::result::Result<Self, Self::Error> {
|
848 + | let res: ::std::result::Result<::std::collections::HashMap<crate::model::LengthPatternString, crate::model::LengthPatternString>, Self::Error> = value.0
|
849 + | .into_iter()
|
850 + | .map(|(k, v)| {
|
851 + | let k: crate::model::LengthPatternString = k.try_into().map_err(Self::Error::Key)?;
|
852 + |
|
853 + | match crate::model::LengthPatternString::try_from(v) {
|
854 + | Ok(v) => Ok((k, v)),
|
855 + | Err(inner_constraint_violation) => Err(Self::Error::Value(k, inner_constraint_violation)),
|
856 + | }
|
857 + | })
|
858 + | .collect();
|
859 + | let hm = res?;
|
860 + | Ok(Self(hm))
|
861 + | }
|
862 + | }
|
863 + | }
|
864 + | pub(crate) mod map_of_list_of_length_pattern_string_unconstrained {
|
865 + |
|
866 + | #[derive(Debug, Clone)]
|
867 + | pub(crate) struct MapOfListOfLengthPatternStringUnconstrained(pub(crate) std::collections::HashMap<::std::string::String, crate::unconstrained::list_of_length_pattern_string_unconstrained::ListOfLengthPatternStringUnconstrained>);
|
868 + |
|
869 + | impl From<MapOfListOfLengthPatternStringUnconstrained> for crate::constrained::MaybeConstrained<crate::constrained::map_of_list_of_length_pattern_string_constrained::MapOfListOfLengthPatternStringConstrained> {
|
870 + | fn from(value: MapOfListOfLengthPatternStringUnconstrained) -> Self {
|
871 + | Self::Unconstrained(value)
|
872 + | }
|
873 + | }
|
874 + | impl std::convert::TryFrom<MapOfListOfLengthPatternStringUnconstrained> for crate::constrained::map_of_list_of_length_pattern_string_constrained::MapOfListOfLengthPatternStringConstrained {
|
875 + | type Error = crate::model::map_of_list_of_length_pattern_string::ConstraintViolation;
|
876 + | fn try_from(value: MapOfListOfLengthPatternStringUnconstrained) -> std::result::Result<Self, Self::Error> {
|
877 + | let res: ::std::result::Result<::std::collections::HashMap<crate::model::LengthPatternString, crate::constrained::list_of_length_pattern_string_constrained::ListOfLengthPatternStringConstrained>, Self::Error> = value.0
|
878 + | .into_iter()
|
879 + | .map(|(k, v)| {
|
880 + | let k: crate::model::LengthPatternString = k.try_into().map_err(Self::Error::Key)?;
|
881 + |
|
882 + | match crate::constrained::list_of_length_pattern_string_constrained::ListOfLengthPatternStringConstrained::try_from(v) {
|
883 + | Ok(v) => Ok((k, v)),
|
884 + | Err(inner_constraint_violation) => Err(Self::Error::Value(k, inner_constraint_violation)),
|
885 + | }
|
886 + | })
|
887 + | .collect();
|
888 + | let hm = res?;
|
889 + | Ok(Self(hm))
|
890 + | }
|
891 + | }
|
892 + | }
|
893 + | pub(crate) mod map_of_enum_string_unconstrained {
|
894 + |
|
895 + | #[derive(Debug, Clone)]
|
896 + | pub(crate) struct MapOfEnumStringUnconstrained(
|
897 + | pub(crate) std::collections::HashMap<::std::string::String, ::std::string::String>,
|
898 + | );
|
899 + |
|
900 + | impl From<MapOfEnumStringUnconstrained>
|
901 + | for crate::constrained::MaybeConstrained<
|
902 + | crate::constrained::map_of_enum_string_constrained::MapOfEnumStringConstrained,
|
903 + | >
|
904 + | {
|
905 + | fn from(value: MapOfEnumStringUnconstrained) -> Self {
|
906 + | Self::Unconstrained(value)
|
907 + | }
|
908 + | }
|
909 + | impl std::convert::TryFrom<MapOfEnumStringUnconstrained>
|
910 + | for crate::constrained::map_of_enum_string_constrained::MapOfEnumStringConstrained
|
911 + | {
|
912 + | type Error = crate::model::map_of_enum_string::ConstraintViolation;
|
913 + | fn try_from(value: MapOfEnumStringUnconstrained) -> std::result::Result<Self, Self::Error> {
|
914 + | let res: ::std::result::Result<
|
915 + | ::std::collections::HashMap<crate::model::EnumString, crate::model::EnumString>,
|
916 + | Self::Error,
|
852 917 | > = value
|
853 918 | .0
|
854 919 | .into_iter()
|
855 - | .enumerate()
|
856 - | .map(|(idx, inner)| {
|
857 - | inner
|
858 - | .try_into()
|
859 - | .map_err(|inner_violation| (idx, inner_violation))
|
920 + | .map(|(k, v)| {
|
921 + | let k: crate::model::EnumString = k.try_into().map_err(Self::Error::Key)?;
|
922 + |
|
923 + | match crate::model::EnumString::try_from(v) {
|
924 + | Ok(v) => Ok((k, v)),
|
925 + | Err(inner_constraint_violation) => {
|
926 + | Err(Self::Error::Value(k, inner_constraint_violation))
|
927 + | }
|
928 + | }
|
860 929 | })
|
861 930 | .collect();
|
862 - | let inner =
|
863 - | res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
|
864 - | Self::try_from(inner)
|
931 + | let hm = res?;
|
932 + | Ok(Self(hm))
|
865 933 | }
|
866 934 | }
|
867 935 | }
|
868 - | pub(crate) mod list_of_range_byte_unconstrained {
|
936 + | pub(crate) mod con_b_list_unconstrained {
|
869 937 |
|
870 938 | #[derive(Debug, Clone)]
|
871 - | pub(crate) struct ListOfRangeByteUnconstrained(pub(crate) std::vec::Vec<i8>);
|
939 + | pub(crate) struct ConBListUnconstrained(
|
940 + | pub(crate) std::vec::Vec<
|
941 + | crate::unconstrained::con_b_list_inner_unconstrained::ConBListInnerUnconstrained,
|
942 + | >,
|
943 + | );
|
872 944 |
|
873 - | impl From<ListOfRangeByteUnconstrained>
|
945 + | impl From<ConBListUnconstrained>
|
874 946 | for crate::constrained::MaybeConstrained<
|
875 - | crate::constrained::list_of_range_byte_constrained::ListOfRangeByteConstrained,
|
947 + | crate::constrained::con_b_list_constrained::ConBListConstrained,
|
876 948 | >
|
877 949 | {
|
878 - | fn from(value: ListOfRangeByteUnconstrained) -> Self {
|
950 + | fn from(value: ConBListUnconstrained) -> Self {
|
879 951 | Self::Unconstrained(value)
|
880 952 | }
|
881 953 | }
|
882 - | impl std::convert::TryFrom<ListOfRangeByteUnconstrained>
|
883 - | for crate::constrained::list_of_range_byte_constrained::ListOfRangeByteConstrained
|
954 + | impl std::convert::TryFrom<ConBListUnconstrained>
|
955 + | for crate::constrained::con_b_list_constrained::ConBListConstrained
|
884 956 | {
|
885 - | type Error = crate::model::list_of_range_byte::ConstraintViolation;
|
886 - | fn try_from(value: ListOfRangeByteUnconstrained) -> std::result::Result<Self, Self::Error> {
|
957 + | type Error = crate::model::con_b_list::ConstraintViolation;
|
958 + | fn try_from(value: ConBListUnconstrained) -> std::result::Result<Self, Self::Error> {
|
887 959 | let res: ::std::result::Result<
|
888 - | ::std::vec::Vec<crate::model::RangeByte>,
|
889 - | (usize, crate::model::range_byte::ConstraintViolation),
|
960 + | ::std::vec::Vec<
|
961 + | crate::constrained::con_b_list_inner_constrained::ConBListInnerConstrained,
|
962 + | >,
|
963 + | (usize, crate::model::con_b_list_inner::ConstraintViolation),
|
890 964 | > = value
|
891 965 | .0
|
892 966 | .into_iter()
|
893 967 | .enumerate()
|
894 968 | .map(|(idx, inner)| {
|
895 969 | inner
|
896 970 | .try_into()
|
897 971 | .map_err(|inner_violation| (idx, inner_violation))
|
898 972 | })
|
899 973 | .collect();
|
900 974 | let inner =
|
901 975 | res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
|
902 976 | Ok(Self(inner))
|
903 977 | }
|
904 978 | }
|
905 979 | }
|
906 - | pub(crate) mod map_of_range_long_unconstrained {
|
980 + | pub(crate) mod length_list_unconstrained {
|
907 981 |
|
908 982 | #[derive(Debug, Clone)]
|
909 - | pub(crate) struct MapOfRangeLongUnconstrained(
|
910 - | pub(crate) std::collections::HashMap<::std::string::String, i64>,
|
911 - | );
|
983 + | pub(crate) struct LengthListUnconstrained(pub(crate) std::vec::Vec<::std::string::String>);
|
912 984 |
|
913 - | impl From<MapOfRangeLongUnconstrained>
|
914 - | for crate::constrained::MaybeConstrained<
|
915 - | crate::constrained::map_of_range_long_constrained::MapOfRangeLongConstrained,
|
916 - | >
|
985 + | impl From<LengthListUnconstrained>
|
986 + | for crate::constrained::MaybeConstrained<crate::model::LengthList>
|
917 987 | {
|
918 - | fn from(value: MapOfRangeLongUnconstrained) -> Self {
|
988 + | fn from(value: LengthListUnconstrained) -> Self {
|
919 989 | Self::Unconstrained(value)
|
920 990 | }
|
921 991 | }
|
922 - | impl std::convert::TryFrom<MapOfRangeLongUnconstrained>
|
923 - | for crate::constrained::map_of_range_long_constrained::MapOfRangeLongConstrained
|
924 - | {
|
925 - | type Error = crate::model::map_of_range_long::ConstraintViolation;
|
926 - | fn try_from(value: MapOfRangeLongUnconstrained) -> std::result::Result<Self, Self::Error> {
|
927 - | let res: ::std::result::Result<
|
928 - | ::std::collections::HashMap<::std::string::String, crate::model::RangeLong>,
|
929 - | Self::Error,
|
930 - | > = value
|
931 - | .0
|
932 - | .into_iter()
|
933 - | .map(|(k, v)| match crate::model::RangeLong::try_from(v) {
|
934 - | Ok(v) => Ok((k, v)),
|
935 - | Err(inner_constraint_violation) => {
|
936 - | Err(Self::Error::Value(k, inner_constraint_violation))
|
937 - | }
|
938 - | })
|
939 - | .collect();
|
940 - | let hm = res?;
|
941 - | Ok(Self(hm))
|
992 + | impl std::convert::TryFrom<LengthListUnconstrained> for crate::model::LengthList {
|
993 + | type Error = crate::model::length_list::ConstraintViolation;
|
994 + | fn try_from(value: LengthListUnconstrained) -> std::result::Result<Self, Self::Error> {
|
995 + | let inner = value.0;
|
996 + | Self::try_from(inner)
|
942 997 | }
|
943 998 | }
|
944 999 | }
|
945 - | pub(crate) mod set_of_range_long_unconstrained {
|
1000 + | pub(crate) mod sensitive_length_list_unconstrained {
|
946 1001 |
|
947 1002 | #[derive(Debug, Clone)]
|
948 - | pub(crate) struct SetOfRangeLongUnconstrained(pub(crate) std::vec::Vec<i64>);
|
1003 + | pub(crate) struct SensitiveLengthListUnconstrained(
|
1004 + | pub(crate) std::vec::Vec<crate::model::SensitiveStructure>,
|
1005 + | );
|
949 1006 |
|
950 - | impl From<SetOfRangeLongUnconstrained>
|
951 - | for crate::constrained::MaybeConstrained<crate::model::SetOfRangeLong>
|
1007 + | impl From<SensitiveLengthListUnconstrained>
|
1008 + | for crate::constrained::MaybeConstrained<crate::model::SensitiveLengthList>
|
952 1009 | {
|
953 - | fn from(value: SetOfRangeLongUnconstrained) -> Self {
|
1010 + | fn from(value: SensitiveLengthListUnconstrained) -> Self {
|
954 1011 | Self::Unconstrained(value)
|
955 1012 | }
|
956 1013 | }
|
957 - | impl std::convert::TryFrom<SetOfRangeLongUnconstrained> for crate::model::SetOfRangeLong {
|
958 - | type Error = crate::model::set_of_range_long::ConstraintViolation;
|
959 - | fn try_from(value: SetOfRangeLongUnconstrained) -> std::result::Result<Self, Self::Error> {
|
960 - | let res: ::std::result::Result<
|
961 - | ::std::vec::Vec<crate::model::RangeLong>,
|
962 - | (usize, crate::model::range_long::ConstraintViolation),
|
963 - | > = value
|
964 - | .0
|
965 - | .into_iter()
|
966 - | .enumerate()
|
967 - | .map(|(idx, inner)| {
|
968 - | inner
|
969 - | .try_into()
|
970 - | .map_err(|inner_violation| (idx, inner_violation))
|
971 - | })
|
972 - | .collect();
|
973 - | let inner =
|
974 - | res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
|
1014 + | impl std::convert::TryFrom<SensitiveLengthListUnconstrained> for crate::model::SensitiveLengthList {
|
1015 + | type Error = crate::model::sensitive_length_list::ConstraintViolation;
|
1016 + | fn try_from(
|
1017 + | value: SensitiveLengthListUnconstrained,
|
1018 + | ) -> std::result::Result<Self, Self::Error> {
|
1019 + | let inner = value.0;
|
975 1020 | Self::try_from(inner)
|
976 1021 | }
|
977 1022 | }
|
978 1023 | }
|
979 - | pub(crate) mod list_of_range_long_unconstrained {
|
1024 + | pub(crate) mod con_b_set_unconstrained {
|
980 1025 |
|
981 1026 | #[derive(Debug, Clone)]
|
982 - | pub(crate) struct ListOfRangeLongUnconstrained(pub(crate) std::vec::Vec<i64>);
|
1027 + | pub(crate) struct ConBSetUnconstrained(
|
1028 + | pub(crate) std::vec::Vec<
|
1029 + | crate::unconstrained::con_b_set_inner_unconstrained::ConBSetInnerUnconstrained,
|
1030 + | >,
|
1031 + | );
|
983 1032 |
|
984 - | impl From<ListOfRangeLongUnconstrained>
|
985 - | for crate::constrained::MaybeConstrained<
|
986 - | crate::constrained::list_of_range_long_constrained::ListOfRangeLongConstrained,
|
987 - | >
|
988 - | {
|
989 - | fn from(value: ListOfRangeLongUnconstrained) -> Self {
|
1033 + | impl From<ConBSetUnconstrained> for crate::constrained::MaybeConstrained<crate::model::ConBSet> {
|
1034 + | fn from(value: ConBSetUnconstrained) -> Self {
|
990 1035 | Self::Unconstrained(value)
|
991 1036 | }
|
992 1037 | }
|
993 - | impl std::convert::TryFrom<ListOfRangeLongUnconstrained>
|
994 - | for crate::constrained::list_of_range_long_constrained::ListOfRangeLongConstrained
|
995 - | {
|
996 - | type Error = crate::model::list_of_range_long::ConstraintViolation;
|
997 - | fn try_from(value: ListOfRangeLongUnconstrained) -> std::result::Result<Self, Self::Error> {
|
1038 + | impl std::convert::TryFrom<ConBSetUnconstrained> for crate::model::ConBSet {
|
1039 + | type Error = crate::model::con_b_set::ConstraintViolation;
|
1040 + | fn try_from(value: ConBSetUnconstrained) -> std::result::Result<Self, Self::Error> {
|
998 1041 | let res: ::std::result::Result<
|
999 - | ::std::vec::Vec<crate::model::RangeLong>,
|
1000 - | (usize, crate::model::range_long::ConstraintViolation),
|
1042 + | ::std::vec::Vec<crate::model::ConBSetInner>,
|
1043 + | (usize, crate::model::con_b_set_inner::ConstraintViolation),
|
1001 1044 | > = value
|
1002 1045 | .0
|
1003 1046 | .into_iter()
|
1004 1047 | .enumerate()
|
1005 1048 | .map(|(idx, inner)| {
|
1006 1049 | inner
|
1007 1050 | .try_into()
|
1008 1051 | .map_err(|inner_violation| (idx, inner_violation))
|
1009 1052 | })
|
1010 1053 | .collect();
|
1011 1054 | let inner =
|
1012 1055 | res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
|
1013 - | Ok(Self(inner))
|
1056 + | Self::try_from(inner)
|
1014 1057 | }
|
1015 1058 | }
|
1016 1059 | }
|
1017 - | pub(crate) mod map_of_range_short_unconstrained {
|
1060 + | pub(crate) mod length_map_unconstrained {
|
1018 1061 |
|
1019 1062 | #[derive(Debug, Clone)]
|
1020 - | pub(crate) struct MapOfRangeShortUnconstrained(
|
1021 - | pub(crate) std::collections::HashMap<::std::string::String, i16>,
|
1063 + | pub(crate) struct LengthMapUnconstrained(
|
1064 + | pub(crate) std::collections::HashMap<::std::string::String, ::std::string::String>,
|
1022 1065 | );
|
1023 1066 |
|
1024 - | impl From<MapOfRangeShortUnconstrained>
|
1025 - | for crate::constrained::MaybeConstrained<
|
1026 - | crate::constrained::map_of_range_short_constrained::MapOfRangeShortConstrained,
|
1027 - | >
|
1067 + | impl From<LengthMapUnconstrained>
|
1068 + | for crate::constrained::MaybeConstrained<crate::model::LengthMap>
|
1028 1069 | {
|
1029 - | fn from(value: MapOfRangeShortUnconstrained) -> Self {
|
1070 + | fn from(value: LengthMapUnconstrained) -> Self {
|
1030 1071 | Self::Unconstrained(value)
|
1031 1072 | }
|
1032 1073 | }
|
1033 - | impl std::convert::TryFrom<MapOfRangeShortUnconstrained>
|
1034 - | for crate::constrained::map_of_range_short_constrained::MapOfRangeShortConstrained
|
1035 - | {
|
1036 - | type Error = crate::model::map_of_range_short::ConstraintViolation;
|
1037 - | fn try_from(value: MapOfRangeShortUnconstrained) -> std::result::Result<Self, Self::Error> {
|
1038 - | let res: ::std::result::Result<
|
1039 - | ::std::collections::HashMap<::std::string::String, crate::model::RangeShort>,
|
1040 - | Self::Error,
|
1041 - | > = value
|
1042 - | .0
|
1043 - | .into_iter()
|
1044 - | .map(|(k, v)| match crate::model::RangeShort::try_from(v) {
|
1045 - | Ok(v) => Ok((k, v)),
|
1046 - | Err(inner_constraint_violation) => {
|
1047 - | Err(Self::Error::Value(k, inner_constraint_violation))
|
1074 + | impl std::convert::TryFrom<LengthMapUnconstrained> for crate::model::LengthMap {
|
1075 + | type Error = crate::model::length_map::ConstraintViolation;
|
1076 + | fn try_from(value: LengthMapUnconstrained) -> std::result::Result<Self, Self::Error> {
|
1077 + | let hm = value.0;
|
1078 + | Self::try_from(hm)
|
1079 + | }
|
1080 + | }
|
1081 + | }
|
1082 + | pub(crate) mod map_of_map_of_list_of_list_of_con_b_unconstrained {
|
1083 + |
|
1084 + | #[derive(Debug, Clone)]
|
1085 + | pub(crate) struct MapOfMapOfListOfListOfConBUnconstrained(pub(crate) std::collections::HashMap<::std::string::String, crate::unconstrained::map_of_list_of_list_of_con_b_unconstrained::MapOfListOfListOfConBUnconstrained>);
|
1086 + |
|
1087 + | impl From<MapOfMapOfListOfListOfConBUnconstrained> for crate::constrained::MaybeConstrained<crate::constrained::map_of_map_of_list_of_list_of_con_b_constrained::MapOfMapOfListOfListOfConBConstrained> {
|
1088 + | fn from(value: MapOfMapOfListOfListOfConBUnconstrained) -> Self {
|
1089 + | Self::Unconstrained(value)
|
1090 + | }
|
1048 1091 | }
|
1049 - | })
|
1050 - | .collect();
|
1051 - | let hm = res?;
|
1092 + | impl std::convert::TryFrom<MapOfMapOfListOfListOfConBUnconstrained> for crate::constrained::map_of_map_of_list_of_list_of_con_b_constrained::MapOfMapOfListOfListOfConBConstrained {
|
1093 + | type Error = crate::model::map_of_map_of_list_of_list_of_con_b::ConstraintViolation;
|
1094 + | fn try_from(value: MapOfMapOfListOfListOfConBUnconstrained) -> std::result::Result<Self, Self::Error> {
|
1095 + | let res: ::std::result::Result<::std::collections::HashMap<::std::string::String, crate::constrained::map_of_list_of_list_of_con_b_constrained::MapOfListOfListOfConBConstrained>, Self::Error> = value.0
|
1096 + | .into_iter()
|
1097 + | .map(|(k, v)| {
|
1098 + | match crate::constrained::map_of_list_of_list_of_con_b_constrained::MapOfListOfListOfConBConstrained::try_from(v) {
|
1099 + | Ok(v) => Ok((k, v)),
|
1100 + | Err(inner_constraint_violation) => Err(Self::Error::Value(k, inner_constraint_violation)),
|
1101 + | }
|
1102 + | })
|
1103 + | .collect();
|
1104 + | let hm = res?;
|
1052 1105 | Ok(Self(hm))
|
1053 1106 | }
|
1054 1107 | }
|
1055 1108 | }
|
1056 - | pub(crate) mod set_of_range_short_unconstrained {
|
1109 + | pub(crate) mod sparse_map_unconstrained {
|
1057 1110 |
|
1058 1111 | #[derive(Debug, Clone)]
|
1059 - | pub(crate) struct SetOfRangeShortUnconstrained(pub(crate) std::vec::Vec<i16>);
|
1112 + | pub(crate) struct SparseMapUnconstrained(
|
1113 + | pub(crate) std::collections::HashMap<
|
1114 + | ::std::string::String,
|
1115 + | ::std::option::Option<
|
1116 + | crate::unconstrained::unique_items_list_unconstrained::UniqueItemsListUnconstrained,
|
1117 + | >,
|
1118 + | >,
|
1119 + | );
|
1060 1120 |
|
1061 - | impl From<SetOfRangeShortUnconstrained>
|
1062 - | for crate::constrained::MaybeConstrained<crate::model::SetOfRangeShort>
|
1121 + | impl From<SparseMapUnconstrained>
|
1122 + | for crate::constrained::MaybeConstrained<
|
1123 + | crate::constrained::sparse_map_constrained::SparseMapConstrained,
|
1124 + | >
|
1063 1125 | {
|
1064 - | fn from(value: SetOfRangeShortUnconstrained) -> Self {
|
1126 + | fn from(value: SparseMapUnconstrained) -> Self {
|
1065 1127 | Self::Unconstrained(value)
|
1066 1128 | }
|
1067 1129 | }
|
1068 - | impl std::convert::TryFrom<SetOfRangeShortUnconstrained> for crate::model::SetOfRangeShort {
|
1069 - | type Error = crate::model::set_of_range_short::ConstraintViolation;
|
1070 - | fn try_from(value: SetOfRangeShortUnconstrained) -> std::result::Result<Self, Self::Error> {
|
1130 + | impl std::convert::TryFrom<SparseMapUnconstrained>
|
1131 + | for crate::constrained::sparse_map_constrained::SparseMapConstrained
|
1132 + | {
|
1133 + | type Error = crate::model::sparse_map::ConstraintViolation;
|
1134 + | fn try_from(value: SparseMapUnconstrained) -> std::result::Result<Self, Self::Error> {
|
1071 1135 | let res: ::std::result::Result<
|
1072 - | ::std::vec::Vec<crate::model::RangeShort>,
|
1073 - | (usize, crate::model::range_short::ConstraintViolation),
|
1136 + | ::std::collections::HashMap<
|
1137 + | ::std::string::String,
|
1138 + | ::std::option::Option<crate::model::UniqueItemsList>,
|
1139 + | >,
|
1140 + | Self::Error,
|
1074 1141 | > = value
|
1075 1142 | .0
|
1076 1143 | .into_iter()
|
1077 - | .enumerate()
|
1078 - | .map(|(idx, inner)| {
|
1079 - | inner
|
1080 - | .try_into()
|
1081 - | .map_err(|inner_violation| (idx, inner_violation))
|
1144 + | .map(|(k, v)| match v {
|
1145 + | None => Ok((k, None)),
|
1146 + | Some(v) => match crate::model::UniqueItemsList::try_from(v) {
|
1147 + | Ok(v) => Ok((k, Some(v))),
|
1148 + | Err(inner_constraint_violation) => {
|
1149 + | Err(Self::Error::Value(k, inner_constraint_violation))
|
1150 + | }
|
1151 + | },
|
1082 1152 | })
|
1083 1153 | .collect();
|
1084 - | let inner =
|
1085 - | res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
|
1086 - | Self::try_from(inner)
|
1154 + | let hm = res?;
|
1155 + | Ok(Self(hm))
|
1087 1156 | }
|
1088 1157 | }
|
1089 1158 | }
|
1090 - | pub(crate) mod list_of_range_short_unconstrained {
|
1159 + | pub(crate) mod sparse_list_unconstrained {
|
1091 1160 |
|
1092 1161 | #[derive(Debug, Clone)]
|
1093 - | pub(crate) struct ListOfRangeShortUnconstrained(pub(crate) std::vec::Vec<i16>);
|
1162 + | pub(crate) struct SparseListUnconstrained(
|
1163 + | pub(crate) std::vec::Vec<::std::option::Option<::std::string::String>>,
|
1164 + | );
|
1094 1165 |
|
1095 - | impl From<ListOfRangeShortUnconstrained>
|
1166 + | impl From<SparseListUnconstrained>
|
1096 1167 | for crate::constrained::MaybeConstrained<
|
1097 - | crate::constrained::list_of_range_short_constrained::ListOfRangeShortConstrained,
|
1168 + | crate::constrained::sparse_list_constrained::SparseListConstrained,
|
1098 1169 | >
|
1099 1170 | {
|
1100 - | fn from(value: ListOfRangeShortUnconstrained) -> Self {
|
1171 + | fn from(value: SparseListUnconstrained) -> Self {
|
1101 1172 | Self::Unconstrained(value)
|
1102 1173 | }
|
1103 1174 | }
|
1104 - | impl std::convert::TryFrom<ListOfRangeShortUnconstrained>
|
1105 - | for crate::constrained::list_of_range_short_constrained::ListOfRangeShortConstrained
|
1175 + | impl std::convert::TryFrom<SparseListUnconstrained>
|
1176 + | for crate::constrained::sparse_list_constrained::SparseListConstrained
|
1106 1177 | {
|
1107 - | type Error = crate::model::list_of_range_short::ConstraintViolation;
|
1108 - | fn try_from(
|
1109 - | value: ListOfRangeShortUnconstrained,
|
1110 - | ) -> std::result::Result<Self, Self::Error> {
|
1178 + | type Error = crate::model::sparse_list::ConstraintViolation;
|
1179 + | fn try_from(value: SparseListUnconstrained) -> std::result::Result<Self, Self::Error> {
|
1111 1180 | let res: ::std::result::Result<
|
1112 - | ::std::vec::Vec<crate::model::RangeShort>,
|
1113 - | (usize, crate::model::range_short::ConstraintViolation),
|
1181 + | ::std::vec::Vec<::std::option::Option<crate::model::LengthString>>,
|
1182 + | (usize, crate::model::length_string::ConstraintViolation),
|
1114 1183 | > = value
|
1115 1184 | .0
|
1116 1185 | .into_iter()
|
1117 1186 | .enumerate()
|
1118 1187 | .map(|(idx, inner)| {
|
1119 1188 | inner
|
1120 - | .try_into()
|
1121 - | .map_err(|inner_violation| (idx, inner_violation))
|
1189 + | .map(|inner| {
|
1190 + | inner
|
1191 + | .try_into()
|
1192 + | .map_err(|inner_violation| (idx, inner_violation))
|
1193 + | })
|
1194 + | .transpose()
|
1122 1195 | })
|
1123 1196 | .collect();
|
1124 1197 | let inner =
|
1125 1198 | res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
|
1126 1199 | Ok(Self(inner))
|
1127 1200 | }
|
1128 1201 | }
|
1129 1202 | }
|
1130 - | pub(crate) mod map_of_range_integer_unconstrained {
|
1203 + | pub(crate) mod sparse_length_map_unconstrained {
|
1131 1204 |
|
1132 1205 | #[derive(Debug, Clone)]
|
1133 - | pub(crate) struct MapOfRangeIntegerUnconstrained(
|
1134 - | pub(crate) std::collections::HashMap<::std::string::String, i32>,
|
1206 + | pub(crate) struct SparseLengthMapUnconstrained(
|
1207 + | pub(crate) std::collections::HashMap<
|
1208 + | ::std::string::String,
|
1209 + | ::std::option::Option<::std::string::String>,
|
1210 + | >,
|
1135 1211 | );
|
1136 1212 |
|
1137 - | impl From<MapOfRangeIntegerUnconstrained>
|
1138 - | for crate::constrained::MaybeConstrained<
|
1139 - | crate::constrained::map_of_range_integer_constrained::MapOfRangeIntegerConstrained,
|
1140 - | >
|
1213 + | impl From<SparseLengthMapUnconstrained>
|
1214 + | for crate::constrained::MaybeConstrained<crate::model::SparseLengthMap>
|
1141 1215 | {
|
1142 - | fn from(value: MapOfRangeIntegerUnconstrained) -> Self {
|
1216 + | fn from(value: SparseLengthMapUnconstrained) -> Self {
|
1143 1217 | Self::Unconstrained(value)
|
1144 1218 | }
|
1145 1219 | }
|
1146 - | impl std::convert::TryFrom<MapOfRangeIntegerUnconstrained>
|
1147 - | for crate::constrained::map_of_range_integer_constrained::MapOfRangeIntegerConstrained
|
1148 - | {
|
1149 - | type Error = crate::model::map_of_range_integer::ConstraintViolation;
|
1150 - | fn try_from(
|
1151 - | value: MapOfRangeIntegerUnconstrained,
|
1152 - | ) -> std::result::Result<Self, Self::Error> {
|
1153 - | let res: ::std::result::Result<
|
1154 - | ::std::collections::HashMap<::std::string::String, crate::model::RangeInteger>,
|
1155 - | Self::Error,
|
1156 - | > = value
|
1157 - | .0
|
1158 - | .into_iter()
|
1159 - | .map(|(k, v)| match crate::model::RangeInteger::try_from(v) {
|
1160 - | Ok(v) => Ok((k, v)),
|
1161 - | Err(inner_constraint_violation) => {
|
1162 - | Err(Self::Error::Value(k, inner_constraint_violation))
|
1163 - | }
|
1164 - | })
|
1165 - | .collect();
|
1166 - | let hm = res?;
|
1167 - | Ok(Self(hm))
|
1220 + | impl std::convert::TryFrom<SparseLengthMapUnconstrained> for crate::model::SparseLengthMap {
|
1221 + | type Error = crate::model::sparse_length_map::ConstraintViolation;
|
1222 + | fn try_from(value: SparseLengthMapUnconstrained) -> std::result::Result<Self, Self::Error> {
|
1223 + | let hm = value.0;
|
1224 + | Self::try_from(hm)
|
1168 1225 | }
|
1169 1226 | }
|
1170 1227 | }
|
1171 - | pub(crate) mod set_of_range_integer_unconstrained {
|
1228 + | pub(crate) mod sparse_length_list_unconstrained {
|
1172 1229 |
|
1173 1230 | #[derive(Debug, Clone)]
|
1174 - | pub(crate) struct SetOfRangeIntegerUnconstrained(pub(crate) std::vec::Vec<i32>);
|
1231 + | pub(crate) struct SparseLengthListUnconstrained(
|
1232 + | pub(crate) std::vec::Vec<::std::option::Option<::std::string::String>>,
|
1233 + | );
|
1175 1234 |
|
1176 - | impl From<SetOfRangeIntegerUnconstrained>
|
1177 - | for crate::constrained::MaybeConstrained<crate::model::SetOfRangeInteger>
|
1235 + | impl From<SparseLengthListUnconstrained>
|
1236 + | for crate::constrained::MaybeConstrained<crate::model::SparseLengthList>
|
1178 1237 | {
|
1179 - | fn from(value: SetOfRangeIntegerUnconstrained) -> Self {
|
1238 + | fn from(value: SparseLengthListUnconstrained) -> Self {
|
1180 1239 | Self::Unconstrained(value)
|
1181 1240 | }
|
1182 1241 | }
|
1183 - | impl std::convert::TryFrom<SetOfRangeIntegerUnconstrained> for crate::model::SetOfRangeInteger {
|
1184 - | type Error = crate::model::set_of_range_integer::ConstraintViolation;
|
1242 + | impl std::convert::TryFrom<SparseLengthListUnconstrained> for crate::model::SparseLengthList {
|
1243 + | type Error = crate::model::sparse_length_list::ConstraintViolation;
|
1185 1244 | fn try_from(
|
1186 - | value: SetOfRangeIntegerUnconstrained,
|
1245 + | value: SparseLengthListUnconstrained,
|
1187 1246 | ) -> std::result::Result<Self, Self::Error> {
|
1188 - | let res: ::std::result::Result<
|
1189 - | ::std::vec::Vec<crate::model::RangeInteger>,
|
1190 - | (usize, crate::model::range_integer::ConstraintViolation),
|
1191 - | > = value
|
1192 - | .0
|
1193 - | .into_iter()
|
1194 - | .enumerate()
|
1195 - | .map(|(idx, inner)| {
|
1196 - | inner
|
1197 - | .try_into()
|
1198 - | .map_err(|inner_violation| (idx, inner_violation))
|
1199 - | })
|
1200 - | .collect();
|
1201 - | let inner =
|
1202 - | res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
|
1247 + | let inner = value.0;
|
1203 1248 | Self::try_from(inner)
|
1204 1249 | }
|
1205 1250 | }
|
1206 1251 | }
|
1207 - | pub(crate) mod list_of_range_integer_unconstrained {
|
1252 + | pub(crate) mod constrained_union_unconstrained {
|
1208 1253 |
|
1254 + | #[allow(clippy::enum_variant_names)]
|
1209 1255 | #[derive(Debug, Clone)]
|
1210 - | pub(crate) struct ListOfRangeIntegerUnconstrained(pub(crate) std::vec::Vec<i32>);
|
1256 + | pub(crate) enum ConstrainedUnionUnconstrained {
|
1257 + | ConBList(crate::unconstrained::con_b_list_unconstrained::ConBListUnconstrained),
|
1258 + | ConBMap(crate::unconstrained::con_b_map_unconstrained::ConBMapUnconstrained),
|
1259 + | ConBSet(crate::unconstrained::con_b_set_unconstrained::ConBSetUnconstrained),
|
1260 + | ConstrainedStructure(crate::model::con_b::Builder),
|
1261 + | EnumString(::std::string::String),
|
1262 + | LengthString(::std::string::String),
|
1263 + | }
|
1264 + | impl ::std::convert::TryFrom<ConstrainedUnionUnconstrained> for crate::model::ConstrainedUnion {
|
1265 + | type Error = crate::model::constrained_union::ConstraintViolation;
|
1211 1266 |
|
1212 - | impl From<ListOfRangeIntegerUnconstrained>
|
1267 + | fn try_from(
|
1268 + | value: ConstrainedUnionUnconstrained,
|
1269 + | ) -> ::std::result::Result<Self, Self::Error> {
|
1270 + | Ok(
|
1271 + | match value {
|
1272 + | crate::unconstrained::constrained_union_unconstrained::ConstrainedUnionUnconstrained::ConBList(unconstrained) => Self::ConBList(
|
1273 + | {
|
1274 + | let constrained: crate::constrained::con_b_list_constrained::ConBListConstrained = unconstrained
|
1275 + | .try_into()
|
1276 + | .map_err(Self::Error::ConBList)?;
|
1277 + | constrained.into()
|
1278 + | }
|
1279 + | ),
|
1280 + | crate::unconstrained::constrained_union_unconstrained::ConstrainedUnionUnconstrained::ConBMap(unconstrained) => Self::ConBMap(
|
1281 + | unconstrained
|
1282 + | .try_into()
|
1283 + |
|
1284 + |
|
1285 + | .map_err(Self::Error::ConBMap)?
|
1286 + | ),
|
1287 + | crate::unconstrained::constrained_union_unconstrained::ConstrainedUnionUnconstrained::ConBSet(unconstrained) => Self::ConBSet(
|
1288 + | unconstrained
|
1289 + | .try_into()
|
1290 + |
|
1291 + |
|
1292 + | .map_err(Self::Error::ConBSet)?
|
1293 + | ),
|
1294 + | crate::unconstrained::constrained_union_unconstrained::ConstrainedUnionUnconstrained::ConstrainedStructure(unconstrained) => Self::ConstrainedStructure(
|
1295 + | unconstrained
|
1296 + | .try_into()
|
1297 + |
|
1298 + |
|
1299 + | .map_err(Self::Error::ConstrainedStructure)?
|
1300 + | ),
|
1301 + | crate::unconstrained::constrained_union_unconstrained::ConstrainedUnionUnconstrained::EnumString(unconstrained) => Self::EnumString(
|
1302 + | unconstrained
|
1303 + | .try_into()
|
1304 + |
|
1305 + |
|
1306 + | .map_err(Self::Error::EnumString)?
|
1307 + | ),
|
1308 + | crate::unconstrained::constrained_union_unconstrained::ConstrainedUnionUnconstrained::LengthString(unconstrained) => Self::LengthString(
|
1309 + | unconstrained
|
1310 + | .try_into()
|
1311 + |
|
1312 + |
|
1313 + | .map_err(Self::Error::LengthString)?
|
1314 + | ),
|
1315 + | }
|
1316 + | )
|
1317 + | }
|
1318 + | }
|
1319 + | }
|
1320 + | pub(crate) mod list_of_length_blob_unconstrained {
|
1321 + |
|
1322 + | #[derive(Debug, Clone)]
|
1323 + | pub(crate) struct ListOfLengthBlobUnconstrained(
|
1324 + | pub(crate) std::vec::Vec<::aws_smithy_types::Blob>,
|
1325 + | );
|
1326 + |
|
1327 + | impl From<ListOfLengthBlobUnconstrained>
|
1213 1328 | for crate::constrained::MaybeConstrained<
|
1214 - | crate::constrained::list_of_range_integer_constrained::ListOfRangeIntegerConstrained,
|
1329 + | crate::constrained::list_of_length_blob_constrained::ListOfLengthBlobConstrained,
|
1215 1330 | >
|
1216 1331 | {
|
1217 - | fn from(value: ListOfRangeIntegerUnconstrained) -> Self {
|
1332 + | fn from(value: ListOfLengthBlobUnconstrained) -> Self {
|
1218 1333 | Self::Unconstrained(value)
|
1219 1334 | }
|
1220 1335 | }
|
1221 - | impl std::convert::TryFrom<ListOfRangeIntegerUnconstrained>
|
1222 - | for crate::constrained::list_of_range_integer_constrained::ListOfRangeIntegerConstrained
|
1336 + | impl std::convert::TryFrom<ListOfLengthBlobUnconstrained>
|
1337 + | for crate::constrained::list_of_length_blob_constrained::ListOfLengthBlobConstrained
|
1223 1338 | {
|
1224 - | type Error = crate::model::list_of_range_integer::ConstraintViolation;
|
1339 + | type Error = crate::model::list_of_length_blob::ConstraintViolation;
|
1225 1340 | fn try_from(
|
1226 - | value: ListOfRangeIntegerUnconstrained,
|
1341 + | value: ListOfLengthBlobUnconstrained,
|
1227 1342 | ) -> std::result::Result<Self, Self::Error> {
|
1228 1343 | let res: ::std::result::Result<
|
1229 - | ::std::vec::Vec<crate::model::RangeInteger>,
|
1230 - | (usize, crate::model::range_integer::ConstraintViolation),
|
1344 + | ::std::vec::Vec<crate::model::LengthBlob>,
|
1345 + | (usize, crate::model::length_blob::ConstraintViolation),
|
1231 1346 | > = value
|
1232 1347 | .0
|
1233 1348 | .into_iter()
|
1234 1349 | .enumerate()
|
1235 1350 | .map(|(idx, inner)| {
|
1236 1351 | inner
|
1237 1352 | .try_into()
|
1238 1353 | .map_err(|inner_violation| (idx, inner_violation))
|
1239 1354 | })
|
1240 1355 | .collect();
|
1241 1356 | let inner =
|
1242 1357 | res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
|
1243 1358 | Ok(Self(inner))
|
1244 1359 | }
|
1245 1360 | }
|
1246 1361 | }
|
1247 1362 | pub(crate) mod map_of_length_blob_unconstrained {
|
1248 1363 |
|
1249 1364 | #[derive(Debug, Clone)]
|
1250 1365 | pub(crate) struct MapOfLengthBlobUnconstrained(
|
1251 1366 | pub(crate) std::collections::HashMap<::std::string::String, ::aws_smithy_types::Blob>,
|
1252 1367 | );
|
1253 1368 |
|
1254 1369 | impl From<MapOfLengthBlobUnconstrained>
|
1255 1370 | for crate::constrained::MaybeConstrained<
|
1256 1371 | crate::constrained::map_of_length_blob_constrained::MapOfLengthBlobConstrained,
|
1257 1372 | >
|
1258 1373 | {
|
1259 1374 | fn from(value: MapOfLengthBlobUnconstrained) -> Self {
|
1260 1375 | Self::Unconstrained(value)
|
1261 1376 | }
|
1262 1377 | }
|
1263 1378 | impl std::convert::TryFrom<MapOfLengthBlobUnconstrained>
|
1264 1379 | for crate::constrained::map_of_length_blob_constrained::MapOfLengthBlobConstrained
|
1265 1380 | {
|
1266 1381 | type Error = crate::model::map_of_length_blob::ConstraintViolation;
|
1267 1382 | fn try_from(value: MapOfLengthBlobUnconstrained) -> std::result::Result<Self, Self::Error> {
|
1268 1383 | let res: ::std::result::Result<
|
1269 1384 | ::std::collections::HashMap<::std::string::String, crate::model::LengthBlob>,
|
1270 1385 | Self::Error,
|
1271 1386 | > = value
|
1272 1387 | .0
|
1273 1388 | .into_iter()
|
1274 1389 | .map(|(k, v)| match crate::model::LengthBlob::try_from(v) {
|
1275 1390 | Ok(v) => Ok((k, v)),
|
1276 1391 | Err(inner_constraint_violation) => {
|
1277 1392 | Err(Self::Error::Value(k, inner_constraint_violation))
|
1278 1393 | }
|
1279 1394 | })
|
1280 1395 | .collect();
|
1281 1396 | let hm = res?;
|
1282 1397 | Ok(Self(hm))
|
1283 1398 | }
|
1284 1399 | }
|
1285 1400 | }
|
1286 - | pub(crate) mod list_of_length_blob_unconstrained {
|
1401 + | pub(crate) mod map_of_range_integer_unconstrained {
|
1402 + |
|
1403 + | #[derive(Debug, Clone)]
|
1404 + | pub(crate) struct MapOfRangeIntegerUnconstrained(
|
1405 + | pub(crate) std::collections::HashMap<::std::string::String, i32>,
|
1406 + | );
|
1407 + |
|
1408 + | impl From<MapOfRangeIntegerUnconstrained>
|
1409 + | for crate::constrained::MaybeConstrained<
|
1410 + | crate::constrained::map_of_range_integer_constrained::MapOfRangeIntegerConstrained,
|
1411 + | >
|
1412 + | {
|
1413 + | fn from(value: MapOfRangeIntegerUnconstrained) -> Self {
|
1414 + | Self::Unconstrained(value)
|
1415 + | }
|
1416 + | }
|
1417 + | impl std::convert::TryFrom<MapOfRangeIntegerUnconstrained>
|
1418 + | for crate::constrained::map_of_range_integer_constrained::MapOfRangeIntegerConstrained
|
1419 + | {
|
1420 + | type Error = crate::model::map_of_range_integer::ConstraintViolation;
|
1421 + | fn try_from(
|
1422 + | value: MapOfRangeIntegerUnconstrained,
|
1423 + | ) -> std::result::Result<Self, Self::Error> {
|
1424 + | let res: ::std::result::Result<
|
1425 + | ::std::collections::HashMap<::std::string::String, crate::model::RangeInteger>,
|
1426 + | Self::Error,
|
1427 + | > = value
|
1428 + | .0
|
1429 + | .into_iter()
|
1430 + | .map(|(k, v)| match crate::model::RangeInteger::try_from(v) {
|
1431 + | Ok(v) => Ok((k, v)),
|
1432 + | Err(inner_constraint_violation) => {
|
1433 + | Err(Self::Error::Value(k, inner_constraint_violation))
|
1434 + | }
|
1435 + | })
|
1436 + | .collect();
|
1437 + | let hm = res?;
|
1438 + | Ok(Self(hm))
|
1439 + | }
|
1440 + | }
|
1441 + | }
|
1442 + | pub(crate) mod map_of_range_short_unconstrained {
|
1287 1443 |
|
1288 1444 | #[derive(Debug, Clone)]
|
1289 - | pub(crate) struct ListOfLengthBlobUnconstrained(
|
1290 - | pub(crate) std::vec::Vec<::aws_smithy_types::Blob>,
|
1445 + | pub(crate) struct MapOfRangeShortUnconstrained(
|
1446 + | pub(crate) std::collections::HashMap<::std::string::String, i16>,
|
1291 1447 | );
|
1292 1448 |
|
1293 - | impl From<ListOfLengthBlobUnconstrained>
|
1449 + | impl From<MapOfRangeShortUnconstrained>
|
1294 1450 | for crate::constrained::MaybeConstrained<
|
1295 - | crate::constrained::list_of_length_blob_constrained::ListOfLengthBlobConstrained,
|
1451 + | crate::constrained::map_of_range_short_constrained::MapOfRangeShortConstrained,
|
1296 1452 | >
|
1297 1453 | {
|
1298 - | fn from(value: ListOfLengthBlobUnconstrained) -> Self {
|
1454 + | fn from(value: MapOfRangeShortUnconstrained) -> Self {
|
1299 1455 | Self::Unconstrained(value)
|
1300 1456 | }
|
1301 1457 | }
|
1302 - | impl std::convert::TryFrom<ListOfLengthBlobUnconstrained>
|
1303 - | for crate::constrained::list_of_length_blob_constrained::ListOfLengthBlobConstrained
|
1458 + | impl std::convert::TryFrom<MapOfRangeShortUnconstrained>
|
1459 + | for crate::constrained::map_of_range_short_constrained::MapOfRangeShortConstrained
|
1304 1460 | {
|
1305 - | type Error = crate::model::list_of_length_blob::ConstraintViolation;
|
1306 - | fn try_from(
|
1307 - | value: ListOfLengthBlobUnconstrained,
|
1308 - | ) -> std::result::Result<Self, Self::Error> {
|
1461 + | type Error = crate::model::map_of_range_short::ConstraintViolation;
|
1462 + | fn try_from(value: MapOfRangeShortUnconstrained) -> std::result::Result<Self, Self::Error> {
|
1309 1463 | let res: ::std::result::Result<
|
1310 - | ::std::vec::Vec<crate::model::LengthBlob>,
|
1311 - | (usize, crate::model::length_blob::ConstraintViolation),
|
1464 + | ::std::collections::HashMap<::std::string::String, crate::model::RangeShort>,
|
1465 + | Self::Error,
|
1312 1466 | > = value
|
1313 1467 | .0
|
1314 1468 | .into_iter()
|
1315 - | .enumerate()
|
1316 - | .map(|(idx, inner)| {
|
1317 - | inner
|
1318 - | .try_into()
|
1319 - | .map_err(|inner_violation| (idx, inner_violation))
|
1469 + | .map(|(k, v)| match crate::model::RangeShort::try_from(v) {
|
1470 + | Ok(v) => Ok((k, v)),
|
1471 + | Err(inner_constraint_violation) => {
|
1472 + | Err(Self::Error::Value(k, inner_constraint_violation))
|
1473 + | }
|
1320 1474 | })
|
1321 1475 | .collect();
|
1322 - | let inner =
|
1323 - | res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
|
1324 - | Ok(Self(inner))
|
1325 - | }
|
1326 - | }
|
1327 - | }
|
1328 - | pub(crate) mod constrained_union_unconstrained {
|
1329 - |
|
1330 - | #[allow(clippy::enum_variant_names)]
|
1331 - | #[derive(Debug, Clone)]
|
1332 - | pub(crate) enum ConstrainedUnionUnconstrained {
|
1333 - | ConBList(crate::unconstrained::con_b_list_unconstrained::ConBListUnconstrained),
|
1334 - | ConBMap(crate::unconstrained::con_b_map_unconstrained::ConBMapUnconstrained),
|
1335 - | ConBSet(crate::unconstrained::con_b_set_unconstrained::ConBSetUnconstrained),
|
1336 - | ConstrainedStructure(crate::model::con_b::Builder),
|
1337 - | EnumString(::std::string::String),
|
1338 - | LengthString(::std::string::String),
|
1339 - | }
|
1340 - | impl ::std::convert::TryFrom<ConstrainedUnionUnconstrained> for crate::model::ConstrainedUnion {
|
1341 - | type Error = crate::model::constrained_union::ConstraintViolation;
|
1342 - |
|
1343 - | fn try_from(
|
1344 - | value: ConstrainedUnionUnconstrained,
|
1345 - | ) -> ::std::result::Result<Self, Self::Error> {
|
1346 - | Ok(
|
1347 - | match value {
|
1348 - | crate::unconstrained::constrained_union_unconstrained::ConstrainedUnionUnconstrained::ConBList(unconstrained) => Self::ConBList(
|
1349 - | {
|
1350 - | let constrained: crate::constrained::con_b_list_constrained::ConBListConstrained = unconstrained
|
1351 - | .try_into()
|
1352 - | .map_err(Self::Error::ConBList)?;
|
1353 - | constrained.into()
|
1354 - | }
|
1355 - | ),
|
1356 - | crate::unconstrained::constrained_union_unconstrained::ConstrainedUnionUnconstrained::ConBMap(unconstrained) => Self::ConBMap(
|
1357 - | unconstrained
|
1358 - | .try_into()
|
1359 - |
|
1360 - |
|
1361 - | .map_err(Self::Error::ConBMap)?
|
1362 - | ),
|
1363 - | crate::unconstrained::constrained_union_unconstrained::ConstrainedUnionUnconstrained::ConBSet(unconstrained) => Self::ConBSet(
|
1364 - | unconstrained
|
1365 - | .try_into()
|
1366 - |
|
1367 - |
|
1368 - | .map_err(Self::Error::ConBSet)?
|
1369 - | ),
|
1370 - | crate::unconstrained::constrained_union_unconstrained::ConstrainedUnionUnconstrained::ConstrainedStructure(unconstrained) => Self::ConstrainedStructure(
|
1371 - | unconstrained
|
1372 - | .try_into()
|
1373 - |
|
1374 - |
|
1375 - | .map_err(Self::Error::ConstrainedStructure)?
|
1376 - | ),
|
1377 - | crate::unconstrained::constrained_union_unconstrained::ConstrainedUnionUnconstrained::EnumString(unconstrained) => Self::EnumString(
|
1378 - | unconstrained
|
1379 - | .try_into()
|
1380 - |
|
1381 - |
|
1382 - | .map_err(Self::Error::EnumString)?
|
1383 - | ),
|
1384 - | crate::unconstrained::constrained_union_unconstrained::ConstrainedUnionUnconstrained::LengthString(unconstrained) => Self::LengthString(
|
1385 - | unconstrained
|
1386 - | .try_into()
|
1387 - |
|
1388 - |
|
1389 - | .map_err(Self::Error::LengthString)?
|
1390 - | ),
|
1391 - | }
|
1392 - | )
|
1476 + | let hm = res?;
|
1477 + | Ok(Self(hm))
|
1393 1478 | }
|
1394 1479 | }
|
1395 1480 | }
|
1396 - | pub(crate) mod con_b_set_unconstrained {
|
1481 + | pub(crate) mod map_of_range_long_unconstrained {
|
1397 1482 |
|
1398 1483 | #[derive(Debug, Clone)]
|
1399 - | pub(crate) struct ConBSetUnconstrained(
|
1400 - | pub(crate) std::vec::Vec<
|
1401 - | crate::unconstrained::con_b_set_inner_unconstrained::ConBSetInnerUnconstrained,
|
1402 - | >,
|
1484 + | pub(crate) struct MapOfRangeLongUnconstrained(
|
1485 + | pub(crate) std::collections::HashMap<::std::string::String, i64>,
|
1403 1486 | );
|
1404 1487 |
|
1405 - | impl From<ConBSetUnconstrained> for crate::constrained::MaybeConstrained<crate::model::ConBSet> {
|
1406 - | fn from(value: ConBSetUnconstrained) -> Self {
|
1488 + | impl From<MapOfRangeLongUnconstrained>
|
1489 + | for crate::constrained::MaybeConstrained<
|
1490 + | crate::constrained::map_of_range_long_constrained::MapOfRangeLongConstrained,
|
1491 + | >
|
1492 + | {
|
1493 + | fn from(value: MapOfRangeLongUnconstrained) -> Self {
|
1407 1494 | Self::Unconstrained(value)
|
1408 1495 | }
|
1409 1496 | }
|
1410 - | impl std::convert::TryFrom<ConBSetUnconstrained> for crate::model::ConBSet {
|
1411 - | type Error = crate::model::con_b_set::ConstraintViolation;
|
1412 - | fn try_from(value: ConBSetUnconstrained) -> std::result::Result<Self, Self::Error> {
|
1497 + | impl std::convert::TryFrom<MapOfRangeLongUnconstrained>
|
1498 + | for crate::constrained::map_of_range_long_constrained::MapOfRangeLongConstrained
|
1499 + | {
|
1500 + | type Error = crate::model::map_of_range_long::ConstraintViolation;
|
1501 + | fn try_from(value: MapOfRangeLongUnconstrained) -> std::result::Result<Self, Self::Error> {
|
1413 1502 | let res: ::std::result::Result<
|
1414 - | ::std::vec::Vec<crate::model::ConBSetInner>,
|
1415 - | (usize, crate::model::con_b_set_inner::ConstraintViolation),
|
1503 + | ::std::collections::HashMap<::std::string::String, crate::model::RangeLong>,
|
1504 + | Self::Error,
|
1416 1505 | > = value
|
1417 1506 | .0
|
1418 1507 | .into_iter()
|
1419 - | .enumerate()
|
1420 - | .map(|(idx, inner)| {
|
1421 - | inner
|
1422 - | .try_into()
|
1423 - | .map_err(|inner_violation| (idx, inner_violation))
|
1508 + | .map(|(k, v)| match crate::model::RangeLong::try_from(v) {
|
1509 + | Ok(v) => Ok((k, v)),
|
1510 + | Err(inner_constraint_violation) => {
|
1511 + | Err(Self::Error::Value(k, inner_constraint_violation))
|
1512 + | }
|
1424 1513 | })
|
1425 1514 | .collect();
|
1426 - | let inner =
|
1427 - | res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
|
1428 - | Self::try_from(inner)
|
1429 - | }
|
1430 - | }
|
1431 - | }
|
1432 - | pub(crate) mod con_b_set_inner_unconstrained {
|
1433 - |
|
1434 - | #[derive(Debug, Clone)]
|
1435 - | pub(crate) struct ConBSetInnerUnconstrained(pub(crate) std::vec::Vec<::std::string::String>);
|
1436 - |
|
1437 - | impl From<ConBSetInnerUnconstrained>
|
1438 - | for crate::constrained::MaybeConstrained<crate::model::ConBSetInner>
|
1439 - | {
|
1440 - | fn from(value: ConBSetInnerUnconstrained) -> Self {
|
1441 - | Self::Unconstrained(value)
|
1442 - | }
|
1443 - | }
|
1444 - | impl std::convert::TryFrom<ConBSetInnerUnconstrained> for crate::model::ConBSetInner {
|
1445 - | type Error = crate::model::con_b_set_inner::ConstraintViolation;
|
1446 - | fn try_from(value: ConBSetInnerUnconstrained) -> std::result::Result<Self, Self::Error> {
|
1447 - | let inner = value.0;
|
1448 - | Self::try_from(inner)
|
1515 + | let hm = res?;
|
1516 + | Ok(Self(hm))
|
1449 1517 | }
|
1450 1518 | }
|
1451 1519 | }
|
1452 - | pub(crate) mod con_b_list_unconstrained {
|
1520 + | pub(crate) mod map_of_range_byte_unconstrained {
|
1453 1521 |
|
1454 1522 | #[derive(Debug, Clone)]
|
1455 - | pub(crate) struct ConBListUnconstrained(
|
1456 - | pub(crate) std::vec::Vec<
|
1457 - | crate::unconstrained::con_b_list_inner_unconstrained::ConBListInnerUnconstrained,
|
1458 - | >,
|
1523 + | pub(crate) struct MapOfRangeByteUnconstrained(
|
1524 + | pub(crate) std::collections::HashMap<::std::string::String, i8>,
|
1459 1525 | );
|
1460 1526 |
|
1461 - | impl From<ConBListUnconstrained>
|
1527 + | impl From<MapOfRangeByteUnconstrained>
|
1462 1528 | for crate::constrained::MaybeConstrained<
|
1463 - | crate::constrained::con_b_list_constrained::ConBListConstrained,
|
1529 + | crate::constrained::map_of_range_byte_constrained::MapOfRangeByteConstrained,
|
1464 1530 | >
|
1465 1531 | {
|
1466 - | fn from(value: ConBListUnconstrained) -> Self {
|
1532 + | fn from(value: MapOfRangeByteUnconstrained) -> Self {
|
1467 1533 | Self::Unconstrained(value)
|
1468 1534 | }
|
1469 1535 | }
|
1470 - | impl std::convert::TryFrom<ConBListUnconstrained>
|
1471 - | for crate::constrained::con_b_list_constrained::ConBListConstrained
|
1536 + | impl std::convert::TryFrom<MapOfRangeByteUnconstrained>
|
1537 + | for crate::constrained::map_of_range_byte_constrained::MapOfRangeByteConstrained
|
1472 1538 | {
|
1473 - | type Error = crate::model::con_b_list::ConstraintViolation;
|
1474 - | fn try_from(value: ConBListUnconstrained) -> std::result::Result<Self, Self::Error> {
|
1539 + | type Error = crate::model::map_of_range_byte::ConstraintViolation;
|
1540 + | fn try_from(value: MapOfRangeByteUnconstrained) -> std::result::Result<Self, Self::Error> {
|
1475 1541 | let res: ::std::result::Result<
|
1476 - | ::std::vec::Vec<
|
1477 - | crate::constrained::con_b_list_inner_constrained::ConBListInnerConstrained,
|
1478 - | >,
|
1479 - | (usize, crate::model::con_b_list_inner::ConstraintViolation),
|
1542 + | ::std::collections::HashMap<::std::string::String, crate::model::RangeByte>,
|
1543 + | Self::Error,
|
1480 1544 | > = value
|
1481 1545 | .0
|
1482 1546 | .into_iter()
|
1483 - | .enumerate()
|
1484 - | .map(|(idx, inner)| {
|
1485 - | inner
|
1486 - | .try_into()
|
1487 - | .map_err(|inner_violation| (idx, inner_violation))
|
1547 + | .map(|(k, v)| match crate::model::RangeByte::try_from(v) {
|
1548 + | Ok(v) => Ok((k, v)),
|
1549 + | Err(inner_constraint_violation) => {
|
1550 + | Err(Self::Error::Value(k, inner_constraint_violation))
|
1551 + | }
|
1488 1552 | })
|
1489 1553 | .collect();
|
1490 - | let inner =
|
1491 - | res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
|
1492 - | Ok(Self(inner))
|
1554 + | let hm = res?;
|
1555 + | Ok(Self(hm))
|
1493 1556 | }
|
1494 1557 | }
|
1495 1558 | }
|
1496 - | pub(crate) mod con_b_list_inner_unconstrained {
|
1559 + | pub(crate) mod list_of_pattern_string_unconstrained {
|
1497 1560 |
|
1498 1561 | #[derive(Debug, Clone)]
|
1499 - | pub(crate) struct ConBListInnerUnconstrained(
|
1500 - | pub(crate) std::vec::Vec<crate::model::con_b::Builder>,
|
1562 + | pub(crate) struct ListOfPatternStringUnconstrained(
|
1563 + | pub(crate) std::vec::Vec<::std::string::String>,
|
1501 1564 | );
|
1502 1565 |
|
1503 - | impl From<ConBListInnerUnconstrained>
|
1566 + | impl From<ListOfPatternStringUnconstrained>
|
1504 1567 | for crate::constrained::MaybeConstrained<
|
1505 - | crate::constrained::con_b_list_inner_constrained::ConBListInnerConstrained,
|
1568 + | crate::constrained::list_of_pattern_string_constrained::ListOfPatternStringConstrained,
|
1506 1569 | >
|
1507 1570 | {
|
1508 - | fn from(value: ConBListInnerUnconstrained) -> Self {
|
1571 + | fn from(value: ListOfPatternStringUnconstrained) -> Self {
|
1509 1572 | Self::Unconstrained(value)
|
1510 1573 | }
|
1511 1574 | }
|
1512 - | impl std::convert::TryFrom<ConBListInnerUnconstrained>
|
1513 - | for crate::constrained::con_b_list_inner_constrained::ConBListInnerConstrained
|
1575 + | impl std::convert::TryFrom<ListOfPatternStringUnconstrained>
|
1576 + | for crate::constrained::list_of_pattern_string_constrained::ListOfPatternStringConstrained
|
1514 1577 | {
|
1515 - | type Error = crate::model::con_b_list_inner::ConstraintViolation;
|
1516 - | fn try_from(value: ConBListInnerUnconstrained) -> std::result::Result<Self, Self::Error> {
|
1578 + | type Error = crate::model::list_of_pattern_string::ConstraintViolation;
|
1579 + | fn try_from(
|
1580 + | value: ListOfPatternStringUnconstrained,
|
1581 + | ) -> std::result::Result<Self, Self::Error> {
|
1517 1582 | let res: ::std::result::Result<
|
1518 - | ::std::vec::Vec<crate::model::ConB>,
|
1519 - | (usize, crate::model::con_b::ConstraintViolation),
|
1583 + | ::std::vec::Vec<crate::model::PatternString>,
|
1584 + | (usize, crate::model::pattern_string::ConstraintViolation),
|
1520 1585 | > = value
|
1521 1586 | .0
|
1522 1587 | .into_iter()
|
1523 1588 | .enumerate()
|
1524 1589 | .map(|(idx, inner)| {
|
1525 1590 | inner
|
1526 1591 | .try_into()
|
1527 1592 | .map_err(|inner_violation| (idx, inner_violation))
|
1528 1593 | })
|
1529 1594 | .collect();
|
1530 1595 | let inner =
|
1531 1596 | res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
|
1532 1597 | Ok(Self(inner))
|
1533 1598 | }
|
1534 1599 | }
|
1535 1600 | }
|
1536 - | pub(crate) mod sparse_length_list_unconstrained {
|
1601 + | pub(crate) mod set_of_pattern_string_unconstrained {
|
1537 1602 |
|
1538 1603 | #[derive(Debug, Clone)]
|
1539 - | pub(crate) struct SparseLengthListUnconstrained(
|
1540 - | pub(crate) std::vec::Vec<::std::option::Option<::std::string::String>>,
|
1604 + | pub(crate) struct SetOfPatternStringUnconstrained(
|
1605 + | pub(crate) std::vec::Vec<::std::string::String>,
|
1541 1606 | );
|
1542 1607 |
|
1543 - | impl From<SparseLengthListUnconstrained>
|
1544 - | for crate::constrained::MaybeConstrained<crate::model::SparseLengthList>
|
1608 + | impl From<SetOfPatternStringUnconstrained>
|
1609 + | for crate::constrained::MaybeConstrained<crate::model::SetOfPatternString>
|
1545 1610 | {
|
1546 - | fn from(value: SparseLengthListUnconstrained) -> Self {
|
1611 + | fn from(value: SetOfPatternStringUnconstrained) -> Self {
|
1547 1612 | Self::Unconstrained(value)
|
1548 1613 | }
|
1549 1614 | }
|
1550 - | impl std::convert::TryFrom<SparseLengthListUnconstrained> for crate::model::SparseLengthList {
|
1551 - | type Error = crate::model::sparse_length_list::ConstraintViolation;
|
1615 + | impl std::convert::TryFrom<SetOfPatternStringUnconstrained> for crate::model::SetOfPatternString {
|
1616 + | type Error = crate::model::set_of_pattern_string::ConstraintViolation;
|
1552 1617 | fn try_from(
|
1553 - | value: SparseLengthListUnconstrained,
|
1618 + | value: SetOfPatternStringUnconstrained,
|
1554 1619 | ) -> std::result::Result<Self, Self::Error> {
|
1555 - | let inner = value.0;
|
1620 + | let res: ::std::result::Result<
|
1621 + | ::std::vec::Vec<crate::model::PatternString>,
|
1622 + | (usize, crate::model::pattern_string::ConstraintViolation),
|
1623 + | > = value
|
1624 + | .0
|
1625 + | .into_iter()
|
1626 + | .enumerate()
|
1627 + | .map(|(idx, inner)| {
|
1628 + | inner
|
1629 + | .try_into()
|
1630 + | .map_err(|inner_violation| (idx, inner_violation))
|
1631 + | })
|
1632 + | .collect();
|
1633 + | let inner =
|
1634 + | res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
|
1556 1635 | Self::try_from(inner)
|
1557 1636 | }
|
1558 1637 | }
|
1559 1638 | }
|
1560 - | pub(crate) mod sparse_length_map_unconstrained {
|
1639 + | pub(crate) mod list_of_length_pattern_string_unconstrained {
|
1561 1640 |
|
1562 1641 | #[derive(Debug, Clone)]
|
1563 - | pub(crate) struct SparseLengthMapUnconstrained(
|
1564 - | pub(crate) std::collections::HashMap<
|
1565 - | ::std::string::String,
|
1566 - | ::std::option::Option<::std::string::String>,
|
1567 - | >,
|
1642 + | pub(crate) struct ListOfLengthPatternStringUnconstrained(
|
1643 + | pub(crate) std::vec::Vec<::std::string::String>,
|
1568 1644 | );
|
1569 1645 |
|
1570 - | impl From<SparseLengthMapUnconstrained>
|
1571 - | for crate::constrained::MaybeConstrained<crate::model::SparseLengthMap>
|
1572 - | {
|
1573 - | fn from(value: SparseLengthMapUnconstrained) -> Self {
|
1574 - | Self::Unconstrained(value)
|
1575 - | }
|
1576 - | }
|
1577 - | impl std::convert::TryFrom<SparseLengthMapUnconstrained> for crate::model::SparseLengthMap {
|
1578 - | type Error = crate::model::sparse_length_map::ConstraintViolation;
|
1579 - | fn try_from(value: SparseLengthMapUnconstrained) -> std::result::Result<Self, Self::Error> {
|
1580 - | let hm = value.0;
|
1581 - | Self::try_from(hm)
|
1646 + | impl From<ListOfLengthPatternStringUnconstrained> for crate::constrained::MaybeConstrained<crate::constrained::list_of_length_pattern_string_constrained::ListOfLengthPatternStringConstrained> {
|
1647 + | fn from(value: ListOfLengthPatternStringUnconstrained) -> Self {
|
1648 + | Self::Unconstrained(value)
|
1649 + | }
|
1650 + | }
|
1651 + | impl std::convert::TryFrom<ListOfLengthPatternStringUnconstrained> for crate::constrained::list_of_length_pattern_string_constrained::ListOfLengthPatternStringConstrained {
|
1652 + | type Error = crate::model::list_of_length_pattern_string::ConstraintViolation;
|
1653 + | fn try_from(value: ListOfLengthPatternStringUnconstrained) -> std::result::Result<Self, Self::Error> {
|
1654 + | let res: ::std::result::Result<::std::vec::Vec<crate::model::LengthPatternString>, (usize, crate::model::length_pattern_string::ConstraintViolation) > = value
|
1655 + | .0
|
1656 + | .into_iter()
|
1657 + | .enumerate()
|
1658 + | .map(|(idx, inner)| {
|
1659 + | inner.try_into().map_err(|inner_violation| (idx, inner_violation))
|
1660 + | })
|
1661 + | .collect();
|
1662 + | let inner = res
|
1663 + |
|
1664 + | .map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
|
1665 + | Ok(Self(inner))
|
1582 1666 | }
|
1583 1667 | }
|
1584 1668 | }
|
1585 - | pub(crate) mod sparse_list_unconstrained {
|
1669 + | pub(crate) mod set_of_length_pattern_string_unconstrained {
|
1586 1670 |
|
1587 1671 | #[derive(Debug, Clone)]
|
1588 - | pub(crate) struct SparseListUnconstrained(
|
1589 - | pub(crate) std::vec::Vec<::std::option::Option<::std::string::String>>,
|
1672 + | pub(crate) struct SetOfLengthPatternStringUnconstrained(
|
1673 + | pub(crate) std::vec::Vec<::std::string::String>,
|
1590 1674 | );
|
1591 1675 |
|
1592 - | impl From<SparseListUnconstrained>
|
1593 - | for crate::constrained::MaybeConstrained<
|
1594 - | crate::constrained::sparse_list_constrained::SparseListConstrained,
|
1595 - | >
|
1676 + | impl From<SetOfLengthPatternStringUnconstrained>
|
1677 + | for crate::constrained::MaybeConstrained<crate::model::SetOfLengthPatternString>
|
1596 1678 | {
|
1597 - | fn from(value: SparseListUnconstrained) -> Self {
|
1679 + | fn from(value: SetOfLengthPatternStringUnconstrained) -> Self {
|
1598 1680 | Self::Unconstrained(value)
|
1599 1681 | }
|
1600 1682 | }
|
1601 - | impl std::convert::TryFrom<SparseListUnconstrained>
|
1602 - | for crate::constrained::sparse_list_constrained::SparseListConstrained
|
1683 + | impl std::convert::TryFrom<SetOfLengthPatternStringUnconstrained>
|
1684 + | for crate::model::SetOfLengthPatternString
|
1603 1685 | {
|
1604 - | type Error = crate::model::sparse_list::ConstraintViolation;
|
1605 - | fn try_from(value: SparseListUnconstrained) -> std::result::Result<Self, Self::Error> {
|
1686 + | type Error = crate::model::set_of_length_pattern_string::ConstraintViolation;
|
1687 + | fn try_from(
|
1688 + | value: SetOfLengthPatternStringUnconstrained,
|
1689 + | ) -> std::result::Result<Self, Self::Error> {
|
1606 1690 | let res: ::std::result::Result<
|
1607 - | ::std::vec::Vec<::std::option::Option<crate::model::LengthString>>,
|
1608 - | (usize, crate::model::length_string::ConstraintViolation),
|
1691 + | ::std::vec::Vec<crate::model::LengthPatternString>,
|
1692 + | (
|
1693 + | usize,
|
1694 + | crate::model::length_pattern_string::ConstraintViolation,
|
1695 + | ),
|
1609 1696 | > = value
|
1610 1697 | .0
|
1611 1698 | .into_iter()
|
1612 1699 | .enumerate()
|
1613 1700 | .map(|(idx, inner)| {
|
1614 1701 | inner
|
1615 - | .map(|inner| {
|
1616 - | inner
|
1617 - | .try_into()
|
1618 - | .map_err(|inner_violation| (idx, inner_violation))
|
1619 - | })
|
1620 - | .transpose()
|
1702 + | .try_into()
|
1703 + | .map_err(|inner_violation| (idx, inner_violation))
|
1621 1704 | })
|
1622 1705 | .collect();
|
1623 1706 | let inner =
|
1624 1707 | res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
|
1625 - | Ok(Self(inner))
|
1708 + | Self::try_from(inner)
|
1626 1709 | }
|
1627 1710 | }
|
1628 1711 | }
|
1629 - | pub(crate) mod sparse_map_unconstrained {
|
1712 + | pub(crate) mod con_b_list_inner_unconstrained {
|
1630 1713 |
|
1631 1714 | #[derive(Debug, Clone)]
|
1632 - | pub(crate) struct SparseMapUnconstrained(
|
1633 - | pub(crate) std::collections::HashMap<
|
1634 - | ::std::string::String,
|
1635 - | ::std::option::Option<
|
1636 - | crate::unconstrained::unique_items_list_unconstrained::UniqueItemsListUnconstrained,
|
1637 - | >,
|
1638 - | >,
|
1715 + | pub(crate) struct ConBListInnerUnconstrained(
|
1716 + | pub(crate) std::vec::Vec<crate::model::con_b::Builder>,
|
1639 1717 | );
|
1640 1718 |
|
1641 - | impl From<SparseMapUnconstrained>
|
1719 + | impl From<ConBListInnerUnconstrained>
|
1642 1720 | for crate::constrained::MaybeConstrained<
|
1643 - | crate::constrained::sparse_map_constrained::SparseMapConstrained,
|
1721 + | crate::constrained::con_b_list_inner_constrained::ConBListInnerConstrained,
|
1644 1722 | >
|
1645 1723 | {
|
1646 - | fn from(value: SparseMapUnconstrained) -> Self {
|
1724 + | fn from(value: ConBListInnerUnconstrained) -> Self {
|
1647 1725 | Self::Unconstrained(value)
|
1648 1726 | }
|
1649 1727 | }
|
1650 - | impl std::convert::TryFrom<SparseMapUnconstrained>
|
1651 - | for crate::constrained::sparse_map_constrained::SparseMapConstrained
|
1728 + | impl std::convert::TryFrom<ConBListInnerUnconstrained>
|
1729 + | for crate::constrained::con_b_list_inner_constrained::ConBListInnerConstrained
|
1652 1730 | {
|
1653 - | type Error = crate::model::sparse_map::ConstraintViolation;
|
1654 - | fn try_from(value: SparseMapUnconstrained) -> std::result::Result<Self, Self::Error> {
|
1731 + | type Error = crate::model::con_b_list_inner::ConstraintViolation;
|
1732 + | fn try_from(value: ConBListInnerUnconstrained) -> std::result::Result<Self, Self::Error> {
|
1655 1733 | let res: ::std::result::Result<
|
1656 - | ::std::collections::HashMap<
|
1657 - | ::std::string::String,
|
1658 - | ::std::option::Option<crate::model::UniqueItemsList>,
|
1659 - | >,
|
1660 - | Self::Error,
|
1734 + | ::std::vec::Vec<crate::model::ConB>,
|
1735 + | (usize, crate::model::con_b::ConstraintViolation),
|
1661 1736 | > = value
|
1662 1737 | .0
|
1663 1738 | .into_iter()
|
1664 - | .map(|(k, v)| match v {
|
1665 - | None => Ok((k, None)),
|
1666 - | Some(v) => match crate::model::UniqueItemsList::try_from(v) {
|
1667 - | Ok(v) => Ok((k, Some(v))),
|
1668 - | Err(inner_constraint_violation) => {
|
1669 - | Err(Self::Error::Value(k, inner_constraint_violation))
|
1670 - | }
|
1671 - | },
|
1739 + | .enumerate()
|
1740 + | .map(|(idx, inner)| {
|
1741 + | inner
|
1742 + | .try_into()
|
1743 + | .map_err(|inner_violation| (idx, inner_violation))
|
1672 1744 | })
|
1673 1745 | .collect();
|
1674 - | let hm = res?;
|
1675 - | Ok(Self(hm))
|
1746 + | let inner =
|
1747 + | res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
|
1748 + | Ok(Self(inner))
|
1676 1749 | }
|
1677 1750 | }
|
1678 1751 | }
|
1679 - | pub(crate) mod unique_items_list_unconstrained {
|
1752 + | pub(crate) mod con_b_set_inner_unconstrained {
|
1680 1753 |
|
1681 1754 | #[derive(Debug, Clone)]
|
1682 - | pub(crate) struct UniqueItemsListUnconstrained(pub(crate) std::vec::Vec<::std::string::String>);
|
1755 + | pub(crate) struct ConBSetInnerUnconstrained(pub(crate) std::vec::Vec<::std::string::String>);
|
1683 1756 |
|
1684 - | impl From<UniqueItemsListUnconstrained>
|
1685 - | for crate::constrained::MaybeConstrained<crate::model::UniqueItemsList>
|
1757 + | impl From<ConBSetInnerUnconstrained>
|
1758 + | for crate::constrained::MaybeConstrained<crate::model::ConBSetInner>
|
1686 1759 | {
|
1687 - | fn from(value: UniqueItemsListUnconstrained) -> Self {
|
1760 + | fn from(value: ConBSetInnerUnconstrained) -> Self {
|
1688 1761 | Self::Unconstrained(value)
|
1689 1762 | }
|
1690 1763 | }
|
1691 - | impl std::convert::TryFrom<UniqueItemsListUnconstrained> for crate::model::UniqueItemsList {
|
1692 - | type Error = crate::model::unique_items_list::ConstraintViolation;
|
1693 - | fn try_from(value: UniqueItemsListUnconstrained) -> std::result::Result<Self, Self::Error> {
|
1764 + | impl std::convert::TryFrom<ConBSetInnerUnconstrained> for crate::model::ConBSetInner {
|
1765 + | type Error = crate::model::con_b_set_inner::ConstraintViolation;
|
1766 + | fn try_from(value: ConBSetInnerUnconstrained) -> std::result::Result<Self, Self::Error> {
|
1694 1767 | let inner = value.0;
|
1695 1768 | Self::try_from(inner)
|
1696 1769 | }
|
1697 1770 | }
|
1698 1771 | }
|
1699 - | pub(crate) mod map_of_map_of_list_of_list_of_con_b_unconstrained {
|
1700 - |
|
1701 - | #[derive(Debug, Clone)]
|
1702 - | pub(crate) struct MapOfMapOfListOfListOfConBUnconstrained(pub(crate) std::collections::HashMap<::std::string::String, crate::unconstrained::map_of_list_of_list_of_con_b_unconstrained::MapOfListOfListOfConBUnconstrained>);
|
1703 - |
|
1704 - | impl From<MapOfMapOfListOfListOfConBUnconstrained> for crate::constrained::MaybeConstrained<crate::constrained::map_of_map_of_list_of_list_of_con_b_constrained::MapOfMapOfListOfListOfConBConstrained> {
|
1705 - | fn from(value: MapOfMapOfListOfListOfConBUnconstrained) -> Self {
|
1706 - | Self::Unconstrained(value)
|
1707 - | }
|
1708 - | }
|
1709 - | impl std::convert::TryFrom<MapOfMapOfListOfListOfConBUnconstrained> for crate::constrained::map_of_map_of_list_of_list_of_con_b_constrained::MapOfMapOfListOfListOfConBConstrained {
|
1710 - | type Error = crate::model::map_of_map_of_list_of_list_of_con_b::ConstraintViolation;
|
1711 - | fn try_from(value: MapOfMapOfListOfListOfConBUnconstrained) -> std::result::Result<Self, Self::Error> {
|
1712 - | let res: ::std::result::Result<::std::collections::HashMap<::std::string::String, crate::constrained::map_of_list_of_list_of_con_b_constrained::MapOfListOfListOfConBConstrained>, Self::Error> = value.0
|
1713 - | .into_iter()
|
1714 - | .map(|(k, v)| {
|
1715 - | match crate::constrained::map_of_list_of_list_of_con_b_constrained::MapOfListOfListOfConBConstrained::try_from(v) {
|
1716 - | Ok(v) => Ok((k, v)),
|
1717 - | Err(inner_constraint_violation) => Err(Self::Error::Value(k, inner_constraint_violation)),
|
1718 - | }
|
1719 - | })
|
1720 - | .collect();
|
1721 - | let hm = res?;
|
1722 - | Ok(Self(hm))
|
1723 - | }
|
1724 - | }
|
1725 - | }
|
1726 1772 | pub(crate) mod map_of_list_of_list_of_con_b_unconstrained {
|
1727 1773 |
|
1728 1774 | #[derive(Debug, Clone)]
|
1729 1775 | pub(crate) struct MapOfListOfListOfConBUnconstrained(
|
1730 1776 | pub(crate) std::collections::HashMap<
|
1731 1777 | ::std::string::String,
|
1732 1778 | crate::unconstrained::con_b_list_unconstrained::ConBListUnconstrained,
|
1733 1779 | >,
|
1734 1780 | );
|
1735 1781 |
|
1736 1782 | impl From<MapOfListOfListOfConBUnconstrained> for crate::constrained::MaybeConstrained<crate::constrained::map_of_list_of_list_of_con_b_constrained::MapOfListOfListOfConBConstrained> {
|
1737 1783 | fn from(value: MapOfListOfListOfConBUnconstrained) -> Self {
|
1738 1784 | Self::Unconstrained(value)
|
1739 1785 | }
|
1740 1786 | }
|
1741 1787 | impl std::convert::TryFrom<MapOfListOfListOfConBUnconstrained> for crate::constrained::map_of_list_of_list_of_con_b_constrained::MapOfListOfListOfConBConstrained {
|
1742 1788 | type Error = crate::model::map_of_list_of_list_of_con_b::ConstraintViolation;
|
1743 1789 | fn try_from(value: MapOfListOfListOfConBUnconstrained) -> std::result::Result<Self, Self::Error> {
|
1744 1790 | let res: ::std::result::Result<::std::collections::HashMap<::std::string::String, crate::constrained::con_b_list_constrained::ConBListConstrained>, Self::Error> = value.0
|
1745 1791 | .into_iter()
|
1746 1792 | .map(|(k, v)| {
|
1747 1793 | match crate::constrained::con_b_list_constrained::ConBListConstrained::try_from(v) {
|
1748 1794 | Ok(v) => Ok((k, v)),
|
1749 1795 | Err(inner_constraint_violation) => Err(Self::Error::Value(k, inner_constraint_violation)),
|
1750 1796 | }
|
1751 1797 | })
|
1752 1798 | .collect();
|
1753 1799 | let hm = res?;
|
1754 1800 | Ok(Self(hm))
|
1755 1801 | }
|
1756 1802 | }
|
1757 1803 | }
|
1758 - | pub(crate) mod length_map_unconstrained {
|
1759 - |
|
1760 - | #[derive(Debug, Clone)]
|
1761 - | pub(crate) struct LengthMapUnconstrained(
|
1762 - | pub(crate) std::collections::HashMap<::std::string::String, ::std::string::String>,
|
1763 - | );
|
1764 - |
|
1765 - | impl From<LengthMapUnconstrained>
|
1766 - | for crate::constrained::MaybeConstrained<crate::model::LengthMap>
|
1767 - | {
|
1768 - | fn from(value: LengthMapUnconstrained) -> Self {
|
1769 - | Self::Unconstrained(value)
|
1770 - | }
|
1771 - | }
|
1772 - | impl std::convert::TryFrom<LengthMapUnconstrained> for crate::model::LengthMap {
|
1773 - | type Error = crate::model::length_map::ConstraintViolation;
|
1774 - | fn try_from(value: LengthMapUnconstrained) -> std::result::Result<Self, Self::Error> {
|
1775 - | let hm = value.0;
|
1776 - | Self::try_from(hm)
|
1777 - | }
|
1778 - | }
|
1779 - | }
|
1780 - | pub(crate) mod sensitive_length_list_unconstrained {
|
1781 - |
|
1782 - | #[derive(Debug, Clone)]
|
1783 - | pub(crate) struct SensitiveLengthListUnconstrained(
|
1784 - | pub(crate) std::vec::Vec<crate::model::SensitiveStructure>,
|
1785 - | );
|
1786 - |
|
1787 - | impl From<SensitiveLengthListUnconstrained>
|
1788 - | for crate::constrained::MaybeConstrained<crate::model::SensitiveLengthList>
|
1789 - | {
|
1790 - | fn from(value: SensitiveLengthListUnconstrained) -> Self {
|
1791 - | Self::Unconstrained(value)
|
1792 - | }
|
1793 - | }
|
1794 - | impl std::convert::TryFrom<SensitiveLengthListUnconstrained> for crate::model::SensitiveLengthList {
|
1795 - | type Error = crate::model::sensitive_length_list::ConstraintViolation;
|
1796 - | fn try_from(
|
1797 - | value: SensitiveLengthListUnconstrained,
|
1798 - | ) -> std::result::Result<Self, Self::Error> {
|
1799 - | let inner = value.0;
|
1800 - | Self::try_from(inner)
|
1801 - | }
|
1802 - | }
|
1803 - | }
|
1804 - | pub(crate) mod length_list_unconstrained {
|
1804 + | pub(crate) mod unique_items_list_unconstrained {
|
1805 1805 |
|
1806 1806 | #[derive(Debug, Clone)]
|
1807 - | pub(crate) struct LengthListUnconstrained(pub(crate) std::vec::Vec<::std::string::String>);
|
1807 + | pub(crate) struct UniqueItemsListUnconstrained(pub(crate) std::vec::Vec<::std::string::String>);
|
1808 1808 |
|
1809 - | impl From<LengthListUnconstrained>
|
1810 - | for crate::constrained::MaybeConstrained<crate::model::LengthList>
|
1809 + | impl From<UniqueItemsListUnconstrained>
|
1810 + | for crate::constrained::MaybeConstrained<crate::model::UniqueItemsList>
|
1811 1811 | {
|
1812 - | fn from(value: LengthListUnconstrained) -> Self {
|
1812 + | fn from(value: UniqueItemsListUnconstrained) -> Self {
|
1813 1813 | Self::Unconstrained(value)
|
1814 1814 | }
|
1815 1815 | }
|
1816 - | impl std::convert::TryFrom<LengthListUnconstrained> for crate::model::LengthList {
|
1817 - | type Error = crate::model::length_list::ConstraintViolation;
|
1818 - | fn try_from(value: LengthListUnconstrained) -> std::result::Result<Self, Self::Error> {
|
1816 + | impl std::convert::TryFrom<UniqueItemsListUnconstrained> for crate::model::UniqueItemsList {
|
1817 + | type Error = crate::model::unique_items_list::ConstraintViolation;
|
1818 + | fn try_from(value: UniqueItemsListUnconstrained) -> std::result::Result<Self, Self::Error> {
|
1819 1819 | let inner = value.0;
|
1820 1820 | Self::try_from(inner)
|
1821 1821 | }
|
1822 1822 | }
|
1823 1823 | }
|