1 1 | // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
|
2 2 |
|
3 + | /* UnconstrainedUnionGenerator.kt:121 */
|
3 4 | impl crate::constrained::Constrained for crate::model::ConstrainedUnion {
|
4 5 | type Unconstrained =
|
5 6 | crate::unconstrained::constrained_union_unconstrained::ConstrainedUnionUnconstrained;
|
6 7 | }
|
7 8 |
|
8 9 | impl From<crate::unconstrained::constrained_union_unconstrained::ConstrainedUnionUnconstrained>
|
9 10 | for crate::constrained::MaybeConstrained<crate::model::ConstrainedUnion>
|
10 11 | {
|
11 12 | fn from(
|
12 13 | value: crate::unconstrained::constrained_union_unconstrained::ConstrainedUnionUnconstrained,
|
13 14 | ) -> Self {
|
14 15 | Self::Unconstrained(value)
|
15 16 | }
|
16 17 | }
|
17 18 |
|
18 19 | pub(crate) mod map_of_enum_string_unconstrained {
|
19 20 |
|
21 + | /* UnconstrainedMapGenerator.kt:79 */
|
20 22 | #[derive(Debug, Clone)]
|
21 23 | pub(crate) struct MapOfEnumStringUnconstrained(
|
22 24 | pub(crate) std::collections::HashMap<::std::string::String, ::std::string::String>,
|
23 25 | );
|
24 26 |
|
25 27 | impl From<MapOfEnumStringUnconstrained>
|
26 28 | for crate::constrained::MaybeConstrained<
|
27 29 | crate::constrained::map_of_enum_string_constrained::MapOfEnumStringConstrained,
|
28 30 | >
|
29 31 | {
|
30 32 | fn from(value: MapOfEnumStringUnconstrained) -> Self {
|
31 33 | Self::Unconstrained(value)
|
32 34 | }
|
33 35 | }
|
36 + | /* UnconstrainedMapGenerator.kt:101 */
|
34 37 | impl std::convert::TryFrom<MapOfEnumStringUnconstrained>
|
35 38 | for crate::constrained::map_of_enum_string_constrained::MapOfEnumStringConstrained
|
36 39 | {
|
40 + | /* UnconstrainedMapGenerator.kt:102 */
|
37 41 | type Error = crate::model::map_of_enum_string_internal::ConstraintViolation;
|
42 + | /* UnconstrainedMapGenerator.kt:104 */
|
38 43 | fn try_from(value: MapOfEnumStringUnconstrained) -> std::result::Result<Self, Self::Error> {
|
44 + | /* UnconstrainedMapGenerator.kt:186 */
|
39 45 | let res: ::std::result::Result<
|
40 46 | ::std::collections::HashMap<crate::model::EnumString, crate::model::EnumString>,
|
41 47 | Self::Error,
|
42 48 | > = value
|
43 49 | .0
|
44 50 | .into_iter()
|
45 51 | .map(|(k, v)| {
|
46 52 | let k: crate::model::EnumString = k.try_into().map_err(Self::Error::Key)?;
|
47 53 |
|
48 54 | match crate::model::EnumString::try_from(v) {
|
49 55 | Ok(v) => Ok((k, v)),
|
50 56 | Err(inner_constraint_violation) => {
|
51 57 | Err(Self::Error::Value(k, inner_constraint_violation))
|
52 58 | }
|
53 59 | }
|
54 60 | })
|
55 61 | .collect();
|
56 62 | let hm = res?;
|
63 + | /* UnconstrainedMapGenerator.kt:247 */
|
57 64 | Ok(Self(hm))
|
65 + | /* UnconstrainedMapGenerator.kt:104 */
|
58 66 | }
|
67 + | /* UnconstrainedMapGenerator.kt:101 */
|
59 68 | }
|
69 + |
|
70 + | /* RustCrateInlineModuleComposingWriter.kt:299 */
|
60 71 | }
|
61 72 | pub(crate) mod con_b_map_unconstrained {
|
62 73 |
|
74 + | /* UnconstrainedMapGenerator.kt:79 */
|
63 75 | #[derive(Debug, Clone)]
|
64 76 | pub(crate) struct ConBMapUnconstrained(
|
65 77 | pub(crate) std::collections::HashMap<::std::string::String, ::std::string::String>,
|
66 78 | );
|
67 79 |
|
68 80 | impl From<ConBMapUnconstrained> for crate::constrained::MaybeConstrained<crate::model::ConBMap> {
|
69 81 | fn from(value: ConBMapUnconstrained) -> Self {
|
70 82 | Self::Unconstrained(value)
|
71 83 | }
|
72 84 | }
|
85 + | /* UnconstrainedMapGenerator.kt:101 */
|
73 86 | impl std::convert::TryFrom<ConBMapUnconstrained> for crate::model::ConBMap {
|
87 + | /* UnconstrainedMapGenerator.kt:102 */
|
74 88 | type Error = crate::model::con_b_map_internal::ConstraintViolation;
|
89 + | /* UnconstrainedMapGenerator.kt:104 */
|
75 90 | fn try_from(value: ConBMapUnconstrained) -> std::result::Result<Self, Self::Error> {
|
91 + | /* UnconstrainedMapGenerator.kt:186 */
|
76 92 | let res: ::std::result::Result<
|
77 93 | ::std::collections::HashMap<::std::string::String, crate::model::LengthString>,
|
78 94 | Self::Error,
|
79 95 | > = value
|
80 96 | .0
|
81 97 | .into_iter()
|
82 98 | .map(|(k, v)| match crate::model::LengthString::try_from(v) {
|
83 99 | Ok(v) => Ok((k, v)),
|
84 100 | Err(inner_constraint_violation) => {
|
85 101 | Err(Self::Error::Value(k, inner_constraint_violation))
|
86 102 | }
|
87 103 | })
|
88 104 | .collect();
|
89 105 | let hm = res?;
|
106 + | /* UnconstrainedMapGenerator.kt:245 */
|
90 107 | Self::try_from(hm)
|
108 + | /* UnconstrainedMapGenerator.kt:104 */
|
91 109 | }
|
110 + | /* UnconstrainedMapGenerator.kt:101 */
|
92 111 | }
|
112 + |
|
113 + | /* RustCrateInlineModuleComposingWriter.kt:299 */
|
93 114 | }
|
94 115 | pub(crate) mod map_of_list_of_length_pattern_string_unconstrained {
|
95 116 |
|
117 + | /* UnconstrainedMapGenerator.kt:79 */
|
96 118 | #[derive(Debug, Clone)]
|
97 119 | pub(crate) struct MapOfListOfLengthPatternStringUnconstrained(pub(crate) std::collections::HashMap<::std::string::String, crate::unconstrained::list_of_length_pattern_string_unconstrained::ListOfLengthPatternStringUnconstrained>);
|
98 120 |
|
99 121 | impl From<MapOfListOfLengthPatternStringUnconstrained> for crate::constrained::MaybeConstrained<crate::constrained::map_of_list_of_length_pattern_string_constrained::MapOfListOfLengthPatternStringConstrained> {
|
100 122 | fn from(value: MapOfListOfLengthPatternStringUnconstrained) -> Self {
|
101 123 | Self::Unconstrained(value)
|
102 124 | }
|
103 125 | }
|
126 + | /* UnconstrainedMapGenerator.kt:101 */
|
104 127 | 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_internal::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
|
128 + | /* UnconstrainedMapGenerator.kt:102 */type Error = crate::model::map_of_list_of_length_pattern_string_internal::ConstraintViolation;
|
129 + | /* UnconstrainedMapGenerator.kt:104 */fn try_from(value: MapOfListOfLengthPatternStringUnconstrained) -> std::result::Result<Self, Self::Error> {
|
130 + | /* UnconstrainedMapGenerator.kt:186 */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 131 | .into_iter()
|
109 132 | .map(|(k, v)| {
|
110 133 | let k: crate::model::LengthPatternString = k.try_into().map_err(Self::Error::Key)?;
|
111 134 |
|
112 135 | match crate::constrained::list_of_length_pattern_string_constrained::ListOfLengthPatternStringConstrained::try_from(v) {
|
113 136 | Ok(v) => Ok((k, v)),
|
114 137 | Err(inner_constraint_violation) => Err(Self::Error::Value(k, inner_constraint_violation)),
|
115 138 | }
|
116 139 | })
|
117 140 | .collect();
|
118 141 | let hm = res?;
|
119 - | Ok(Self(hm))
|
120 - | }
|
121 - | }
|
142 + | /* UnconstrainedMapGenerator.kt:247 */Ok(Self(hm))
|
143 + | /* UnconstrainedMapGenerator.kt:104 */}
|
144 + | /* UnconstrainedMapGenerator.kt:101 */}
|
145 + |
|
146 + | /* RustCrateInlineModuleComposingWriter.kt:299 */
|
122 147 | }
|
123 148 | pub(crate) mod list_of_length_pattern_string_unconstrained {
|
124 149 |
|
150 + | /* UnconstrainedCollectionGenerator.kt:77 */
|
125 151 | #[derive(Debug, Clone)]
|
126 152 | pub(crate) struct ListOfLengthPatternStringUnconstrained(
|
127 153 | pub(crate) std::vec::Vec<::std::string::String>,
|
128 154 | );
|
129 155 |
|
130 156 | impl From<ListOfLengthPatternStringUnconstrained> for crate::constrained::MaybeConstrained<crate::constrained::list_of_length_pattern_string_constrained::ListOfLengthPatternStringConstrained> {
|
131 157 | fn from(value: ListOfLengthPatternStringUnconstrained) -> Self {
|
132 158 | Self::Unconstrained(value)
|
133 159 | }
|
134 160 | }
|
161 + | /* UnconstrainedCollectionGenerator.kt:97 */
|
135 162 | 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_internal::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_internal::ConstraintViolation) > = value
|
163 + | /* UnconstrainedCollectionGenerator.kt:98 */type Error = crate::model::list_of_length_pattern_string_internal::ConstraintViolation;
|
164 + | /* UnconstrainedCollectionGenerator.kt:100 */fn try_from(value: ListOfLengthPatternStringUnconstrained) -> std::result::Result<Self, Self::Error> {
|
165 + | /* UnconstrainedCollectionGenerator.kt:127 */let res: ::std::result::Result<::std::vec::Vec<crate::model::LengthPatternString>, (usize, crate::model::length_pattern_string_internal::ConstraintViolation) > = value
|
139 166 | .0
|
140 167 | .into_iter()
|
141 168 | .enumerate()
|
142 169 | .map(|(idx, inner)| {
|
143 170 | inner.try_into().map_err(|inner_violation| (idx, inner_violation))
|
144 171 | })
|
145 172 | .collect();
|
146 173 | let inner = res
|
147 174 |
|
148 175 | .map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
|
149 - | Ok(Self(inner))
|
150 - | }
|
151 - | }
|
176 + | /* UnconstrainedCollectionGenerator.kt:191 */Ok(Self(inner))
|
177 + | /* UnconstrainedCollectionGenerator.kt:100 */}
|
178 + | /* UnconstrainedCollectionGenerator.kt:97 */}
|
179 + |
|
180 + | /* RustCrateInlineModuleComposingWriter.kt:299 */
|
152 181 | }
|
153 182 | pub(crate) mod map_of_length_pattern_string_unconstrained {
|
154 183 |
|
184 + | /* UnconstrainedMapGenerator.kt:79 */
|
155 185 | #[derive(Debug, Clone)]
|
156 186 | pub(crate) struct MapOfLengthPatternStringUnconstrained(
|
157 187 | pub(crate) std::collections::HashMap<::std::string::String, ::std::string::String>,
|
158 188 | );
|
159 189 |
|
160 190 | impl From<MapOfLengthPatternStringUnconstrained> for crate::constrained::MaybeConstrained<crate::constrained::map_of_length_pattern_string_constrained::MapOfLengthPatternStringConstrained> {
|
161 191 | fn from(value: MapOfLengthPatternStringUnconstrained) -> Self {
|
162 192 | Self::Unconstrained(value)
|
163 193 | }
|
164 194 | }
|
195 + | /* UnconstrainedMapGenerator.kt:101 */
|
165 196 | 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_internal::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
|
197 + | /* UnconstrainedMapGenerator.kt:102 */type Error = crate::model::map_of_length_pattern_string_internal::ConstraintViolation;
|
198 + | /* UnconstrainedMapGenerator.kt:104 */fn try_from(value: MapOfLengthPatternStringUnconstrained) -> std::result::Result<Self, Self::Error> {
|
199 + | /* UnconstrainedMapGenerator.kt:186 */let res: ::std::result::Result<::std::collections::HashMap<crate::model::LengthPatternString, crate::model::LengthPatternString>, Self::Error> = value.0
|
169 200 | .into_iter()
|
170 201 | .map(|(k, v)| {
|
171 202 | let k: crate::model::LengthPatternString = k.try_into().map_err(Self::Error::Key)?;
|
172 203 |
|
173 204 | match crate::model::LengthPatternString::try_from(v) {
|
174 205 | Ok(v) => Ok((k, v)),
|
175 206 | Err(inner_constraint_violation) => Err(Self::Error::Value(k, inner_constraint_violation)),
|
176 207 | }
|
177 208 | })
|
178 209 | .collect();
|
179 210 | let hm = res?;
|
180 - | Ok(Self(hm))
|
181 - | }
|
182 - | }
|
211 + | /* UnconstrainedMapGenerator.kt:247 */Ok(Self(hm))
|
212 + | /* UnconstrainedMapGenerator.kt:104 */}
|
213 + | /* UnconstrainedMapGenerator.kt:101 */}
|
214 + |
|
215 + | /* RustCrateInlineModuleComposingWriter.kt:299 */
|
183 216 | }
|
184 217 | pub(crate) mod map_of_list_of_pattern_string_unconstrained {
|
185 218 |
|
219 + | /* UnconstrainedMapGenerator.kt:79 */
|
186 220 | #[derive(Debug, Clone)]
|
187 221 | pub(crate) struct MapOfListOfPatternStringUnconstrained(pub(crate) std::collections::HashMap<::std::string::String, crate::unconstrained::list_of_pattern_string_unconstrained::ListOfPatternStringUnconstrained>);
|
188 222 |
|
189 223 | impl From<MapOfListOfPatternStringUnconstrained> for crate::constrained::MaybeConstrained<crate::constrained::map_of_list_of_pattern_string_constrained::MapOfListOfPatternStringConstrained> {
|
190 224 | fn from(value: MapOfListOfPatternStringUnconstrained) -> Self {
|
191 225 | Self::Unconstrained(value)
|
192 226 | }
|
193 227 | }
|
228 + | /* UnconstrainedMapGenerator.kt:101 */
|
194 229 | 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_internal::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
|
230 + | /* UnconstrainedMapGenerator.kt:102 */type Error = crate::model::map_of_list_of_pattern_string_internal::ConstraintViolation;
|
231 + | /* UnconstrainedMapGenerator.kt:104 */fn try_from(value: MapOfListOfPatternStringUnconstrained) -> std::result::Result<Self, Self::Error> {
|
232 + | /* UnconstrainedMapGenerator.kt:186 */let res: ::std::result::Result<::std::collections::HashMap<crate::model::PatternString, crate::constrained::list_of_pattern_string_constrained::ListOfPatternStringConstrained>, Self::Error> = value.0
|
198 233 | .into_iter()
|
199 234 | .map(|(k, v)| {
|
200 235 | let k: crate::model::PatternString = k.try_into().map_err(Self::Error::Key)?;
|
201 236 |
|
202 237 | match crate::constrained::list_of_pattern_string_constrained::ListOfPatternStringConstrained::try_from(v) {
|
203 238 | Ok(v) => Ok((k, v)),
|
204 239 | Err(inner_constraint_violation) => Err(Self::Error::Value(k, inner_constraint_violation)),
|
205 240 | }
|
206 241 | })
|
207 242 | .collect();
|
208 243 | let hm = res?;
|
209 - | Ok(Self(hm))
|
210 - | }
|
211 - | }
|
244 + | /* UnconstrainedMapGenerator.kt:247 */Ok(Self(hm))
|
245 + | /* UnconstrainedMapGenerator.kt:104 */}
|
246 + | /* UnconstrainedMapGenerator.kt:101 */}
|
247 + |
|
248 + | /* RustCrateInlineModuleComposingWriter.kt:299 */
|
212 249 | }
|
213 250 | pub(crate) mod list_of_pattern_string_unconstrained {
|
214 251 |
|
252 + | /* UnconstrainedCollectionGenerator.kt:77 */
|
215 253 | #[derive(Debug, Clone)]
|
216 254 | pub(crate) struct ListOfPatternStringUnconstrained(
|
217 255 | pub(crate) std::vec::Vec<::std::string::String>,
|
218 256 | );
|
219 257 |
|
220 258 | impl From<ListOfPatternStringUnconstrained>
|
221 259 | for crate::constrained::MaybeConstrained<
|
222 260 | crate::constrained::list_of_pattern_string_constrained::ListOfPatternStringConstrained,
|
223 261 | >
|
224 262 | {
|
225 263 | fn from(value: ListOfPatternStringUnconstrained) -> Self {
|
226 264 | Self::Unconstrained(value)
|
227 265 | }
|
228 266 | }
|
267 + | /* UnconstrainedCollectionGenerator.kt:97 */
|
229 268 | impl std::convert::TryFrom<ListOfPatternStringUnconstrained>
|
230 269 | for crate::constrained::list_of_pattern_string_constrained::ListOfPatternStringConstrained
|
231 270 | {
|
271 + | /* UnconstrainedCollectionGenerator.kt:98 */
|
232 272 | type Error = crate::model::list_of_pattern_string_internal::ConstraintViolation;
|
273 + | /* UnconstrainedCollectionGenerator.kt:100 */
|
233 274 | fn try_from(
|
234 275 | value: ListOfPatternStringUnconstrained,
|
235 276 | ) -> std::result::Result<Self, Self::Error> {
|
277 + | /* UnconstrainedCollectionGenerator.kt:127 */
|
236 278 | let res: ::std::result::Result<
|
237 279 | ::std::vec::Vec<crate::model::PatternString>,
|
238 280 | (
|
239 281 | usize,
|
240 282 | crate::model::pattern_string_internal::ConstraintViolation,
|
241 283 | ),
|
242 284 | > = value
|
243 285 | .0
|
244 286 | .into_iter()
|
245 287 | .enumerate()
|
246 288 | .map(|(idx, inner)| {
|
247 289 | inner
|
248 290 | .try_into()
|
249 291 | .map_err(|inner_violation| (idx, inner_violation))
|
250 292 | })
|
251 293 | .collect();
|
252 294 | let inner =
|
253 295 | res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
|
296 + | /* UnconstrainedCollectionGenerator.kt:191 */
|
254 297 | Ok(Self(inner))
|
298 + | /* UnconstrainedCollectionGenerator.kt:100 */
|
255 299 | }
|
300 + | /* UnconstrainedCollectionGenerator.kt:97 */
|
256 301 | }
|
302 + |
|
303 + | /* RustCrateInlineModuleComposingWriter.kt:299 */
|
257 304 | }
|
258 305 | pub(crate) mod map_of_pattern_string_unconstrained {
|
259 306 |
|
307 + | /* UnconstrainedMapGenerator.kt:79 */
|
260 308 | #[derive(Debug, Clone)]
|
261 309 | pub(crate) struct MapOfPatternStringUnconstrained(
|
262 310 | pub(crate) std::collections::HashMap<::std::string::String, ::std::string::String>,
|
263 311 | );
|
264 312 |
|
265 313 | impl From<MapOfPatternStringUnconstrained>
|
266 314 | for crate::constrained::MaybeConstrained<
|
267 315 | crate::constrained::map_of_pattern_string_constrained::MapOfPatternStringConstrained,
|
268 316 | >
|
269 317 | {
|
270 318 | fn from(value: MapOfPatternStringUnconstrained) -> Self {
|
271 319 | Self::Unconstrained(value)
|
272 320 | }
|
273 321 | }
|
322 + | /* UnconstrainedMapGenerator.kt:101 */
|
274 323 | impl std::convert::TryFrom<MapOfPatternStringUnconstrained>
|
275 324 | for crate::constrained::map_of_pattern_string_constrained::MapOfPatternStringConstrained
|
276 325 | {
|
326 + | /* UnconstrainedMapGenerator.kt:102 */
|
277 327 | type Error = crate::model::map_of_pattern_string_internal::ConstraintViolation;
|
328 + | /* UnconstrainedMapGenerator.kt:104 */
|
278 329 | fn try_from(
|
279 330 | value: MapOfPatternStringUnconstrained,
|
280 331 | ) -> std::result::Result<Self, Self::Error> {
|
332 + | /* UnconstrainedMapGenerator.kt:186 */
|
281 333 | let res: ::std::result::Result<
|
282 334 | ::std::collections::HashMap<
|
283 335 | crate::model::PatternString,
|
284 336 | crate::model::PatternString,
|
285 337 | >,
|
286 338 | Self::Error,
|
287 339 | > = value
|
288 340 | .0
|
289 341 | .into_iter()
|
290 342 | .map(|(k, v)| {
|
291 343 | let k: crate::model::PatternString = k.try_into().map_err(Self::Error::Key)?;
|
292 344 |
|
293 345 | match crate::model::PatternString::try_from(v) {
|
294 346 | Ok(v) => Ok((k, v)),
|
295 347 | Err(inner_constraint_violation) => {
|
296 348 | Err(Self::Error::Value(k, inner_constraint_violation))
|
297 349 | }
|
298 350 | }
|
299 351 | })
|
300 352 | .collect();
|
301 353 | let hm = res?;
|
354 + | /* UnconstrainedMapGenerator.kt:247 */
|
302 355 | Ok(Self(hm))
|
356 + | /* UnconstrainedMapGenerator.kt:104 */
|
303 357 | }
|
358 + | /* UnconstrainedMapGenerator.kt:101 */
|
304 359 | }
|
360 + |
|
361 + | /* RustCrateInlineModuleComposingWriter.kt:299 */
|
305 362 | }
|
306 363 | pub(crate) mod map_of_list_of_enum_string_unconstrained {
|
307 364 |
|
365 + | /* UnconstrainedMapGenerator.kt:79 */
|
308 366 | #[derive(Debug, Clone)]
|
309 367 | pub(crate) struct MapOfListOfEnumStringUnconstrained(
|
310 368 | pub(crate) std::collections::HashMap<
|
311 369 | ::std::string::String,
|
312 370 | crate::unconstrained::list_of_enum_string_unconstrained::ListOfEnumStringUnconstrained,
|
313 371 | >,
|
314 372 | );
|
315 373 |
|
316 374 | impl From<MapOfListOfEnumStringUnconstrained> for crate::constrained::MaybeConstrained<crate::constrained::map_of_list_of_enum_string_constrained::MapOfListOfEnumStringConstrained> {
|
317 375 | fn from(value: MapOfListOfEnumStringUnconstrained) -> Self {
|
318 376 | Self::Unconstrained(value)
|
319 377 | }
|
320 378 | }
|
379 + | /* UnconstrainedMapGenerator.kt:101 */
|
321 380 | impl std::convert::TryFrom<MapOfListOfEnumStringUnconstrained> for crate::constrained::map_of_list_of_enum_string_constrained::MapOfListOfEnumStringConstrained {
|
322 - | type Error = crate::model::map_of_list_of_enum_string_internal::ConstraintViolation;
|
323 - | fn try_from(value: MapOfListOfEnumStringUnconstrained) -> std::result::Result<Self, Self::Error> {
|
324 - | let res: ::std::result::Result<::std::collections::HashMap<crate::model::EnumString, crate::constrained::list_of_enum_string_constrained::ListOfEnumStringConstrained>, Self::Error> = value.0
|
381 + | /* UnconstrainedMapGenerator.kt:102 */type Error = crate::model::map_of_list_of_enum_string_internal::ConstraintViolation;
|
382 + | /* UnconstrainedMapGenerator.kt:104 */fn try_from(value: MapOfListOfEnumStringUnconstrained) -> std::result::Result<Self, Self::Error> {
|
383 + | /* UnconstrainedMapGenerator.kt:186 */let res: ::std::result::Result<::std::collections::HashMap<crate::model::EnumString, crate::constrained::list_of_enum_string_constrained::ListOfEnumStringConstrained>, Self::Error> = value.0
|
325 384 | .into_iter()
|
326 385 | .map(|(k, v)| {
|
327 386 | let k: crate::model::EnumString = k.try_into().map_err(Self::Error::Key)?;
|
328 387 |
|
329 388 | match crate::constrained::list_of_enum_string_constrained::ListOfEnumStringConstrained::try_from(v) {
|
330 389 | Ok(v) => Ok((k, v)),
|
331 390 | Err(inner_constraint_violation) => Err(Self::Error::Value(k, inner_constraint_violation)),
|
332 391 | }
|
333 392 | })
|
334 393 | .collect();
|
335 394 | let hm = res?;
|
336 - | Ok(Self(hm))
|
337 - | }
|
338 - | }
|
395 + | /* UnconstrainedMapGenerator.kt:247 */Ok(Self(hm))
|
396 + | /* UnconstrainedMapGenerator.kt:104 */}
|
397 + | /* UnconstrainedMapGenerator.kt:101 */}
|
398 + |
|
399 + | /* RustCrateInlineModuleComposingWriter.kt:299 */
|
339 400 | }
|
340 401 | pub(crate) mod list_of_enum_string_unconstrained {
|
341 402 |
|
403 + | /* UnconstrainedCollectionGenerator.kt:77 */
|
342 404 | #[derive(Debug, Clone)]
|
343 405 | pub(crate) struct ListOfEnumStringUnconstrained(
|
344 406 | pub(crate) std::vec::Vec<::std::string::String>,
|
345 407 | );
|
346 408 |
|
347 409 | impl From<ListOfEnumStringUnconstrained>
|
348 410 | for crate::constrained::MaybeConstrained<
|
349 411 | crate::constrained::list_of_enum_string_constrained::ListOfEnumStringConstrained,
|
350 412 | >
|
351 413 | {
|
352 414 | fn from(value: ListOfEnumStringUnconstrained) -> Self {
|
353 415 | Self::Unconstrained(value)
|
354 416 | }
|
355 417 | }
|
418 + | /* UnconstrainedCollectionGenerator.kt:97 */
|
356 419 | impl std::convert::TryFrom<ListOfEnumStringUnconstrained>
|
357 420 | for crate::constrained::list_of_enum_string_constrained::ListOfEnumStringConstrained
|
358 421 | {
|
422 + | /* UnconstrainedCollectionGenerator.kt:98 */
|
359 423 | type Error = crate::model::list_of_enum_string_internal::ConstraintViolation;
|
424 + | /* UnconstrainedCollectionGenerator.kt:100 */
|
360 425 | fn try_from(
|
361 426 | value: ListOfEnumStringUnconstrained,
|
362 427 | ) -> std::result::Result<Self, Self::Error> {
|
428 + | /* UnconstrainedCollectionGenerator.kt:127 */
|
363 429 | let res: ::std::result::Result<
|
364 430 | ::std::vec::Vec<crate::model::EnumString>,
|
365 431 | (
|
366 432 | usize,
|
367 433 | crate::model::enum_string_internal::ConstraintViolation,
|
368 434 | ),
|
369 435 | > = value
|
370 436 | .0
|
371 437 | .into_iter()
|
372 438 | .enumerate()
|
373 439 | .map(|(idx, inner)| {
|
374 440 | inner
|
375 441 | .try_into()
|
376 442 | .map_err(|inner_violation| (idx, inner_violation))
|
377 443 | })
|
378 444 | .collect();
|
379 445 | let inner =
|
380 446 | res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
|
447 + | /* UnconstrainedCollectionGenerator.kt:191 */
|
381 448 | Ok(Self(inner))
|
449 + | /* UnconstrainedCollectionGenerator.kt:100 */
|
382 450 | }
|
451 + | /* UnconstrainedCollectionGenerator.kt:97 */
|
383 452 | }
|
453 + |
|
454 + | /* RustCrateInlineModuleComposingWriter.kt:299 */
|
384 455 | }
|
385 456 | pub(crate) mod map_of_length_list_of_pattern_string_unconstrained {
|
386 457 |
|
458 + | /* UnconstrainedMapGenerator.kt:79 */
|
387 459 | #[derive(Debug, Clone)]
|
388 460 | pub(crate) struct MapOfLengthListOfPatternStringUnconstrained(pub(crate) std::collections::HashMap<::std::string::String, crate::unconstrained::length_list_of_pattern_string_unconstrained::LengthListOfPatternStringUnconstrained>);
|
389 461 |
|
390 462 | impl From<MapOfLengthListOfPatternStringUnconstrained> for crate::constrained::MaybeConstrained<crate::constrained::map_of_length_list_of_pattern_string_constrained::MapOfLengthListOfPatternStringConstrained> {
|
391 463 | fn from(value: MapOfLengthListOfPatternStringUnconstrained) -> Self {
|
392 464 | Self::Unconstrained(value)
|
393 465 | }
|
394 466 | }
|
467 + | /* UnconstrainedMapGenerator.kt:101 */
|
395 468 | impl std::convert::TryFrom<MapOfLengthListOfPatternStringUnconstrained> for crate::constrained::map_of_length_list_of_pattern_string_constrained::MapOfLengthListOfPatternStringConstrained {
|
396 - | type Error = crate::model::map_of_length_list_of_pattern_string_internal::ConstraintViolation;
|
397 - | fn try_from(value: MapOfLengthListOfPatternStringUnconstrained) -> std::result::Result<Self, Self::Error> {
|
398 - | let res: ::std::result::Result<::std::collections::HashMap<crate::model::PatternString, crate::model::LengthListOfPatternString>, Self::Error> = value.0
|
469 + | /* UnconstrainedMapGenerator.kt:102 */type Error = crate::model::map_of_length_list_of_pattern_string_internal::ConstraintViolation;
|
470 + | /* UnconstrainedMapGenerator.kt:104 */fn try_from(value: MapOfLengthListOfPatternStringUnconstrained) -> std::result::Result<Self, Self::Error> {
|
471 + | /* UnconstrainedMapGenerator.kt:186 */let res: ::std::result::Result<::std::collections::HashMap<crate::model::PatternString, crate::model::LengthListOfPatternString>, Self::Error> = value.0
|
399 472 | .into_iter()
|
400 473 | .map(|(k, v)| {
|
401 474 | let k: crate::model::PatternString = k.try_into().map_err(Self::Error::Key)?;
|
402 475 |
|
403 476 | match crate::model::LengthListOfPatternString::try_from(v) {
|
404 477 | Ok(v) => Ok((k, v)),
|
405 478 | Err(inner_constraint_violation) => Err(Self::Error::Value(k, inner_constraint_violation)),
|
406 479 | }
|
407 480 | })
|
408 481 | .collect();
|
409 482 | let hm = res?;
|
410 - | Ok(Self(hm))
|
411 - | }
|
412 - | }
|
483 + | /* UnconstrainedMapGenerator.kt:247 */Ok(Self(hm))
|
484 + | /* UnconstrainedMapGenerator.kt:104 */}
|
485 + | /* UnconstrainedMapGenerator.kt:101 */}
|
486 + |
|
487 + | /* RustCrateInlineModuleComposingWriter.kt:299 */
|
413 488 | }
|
414 489 | pub(crate) mod length_list_of_pattern_string_unconstrained {
|
415 490 |
|
491 + | /* UnconstrainedCollectionGenerator.kt:77 */
|
416 492 | #[derive(Debug, Clone)]
|
417 493 | pub(crate) struct LengthListOfPatternStringUnconstrained(
|
418 494 | pub(crate) std::vec::Vec<::std::string::String>,
|
419 495 | );
|
420 496 |
|
421 497 | impl From<LengthListOfPatternStringUnconstrained>
|
422 498 | for crate::constrained::MaybeConstrained<crate::model::LengthListOfPatternString>
|
423 499 | {
|
424 500 | fn from(value: LengthListOfPatternStringUnconstrained) -> Self {
|
425 501 | Self::Unconstrained(value)
|
426 502 | }
|
427 503 | }
|
504 + | /* UnconstrainedCollectionGenerator.kt:97 */
|
428 505 | impl std::convert::TryFrom<LengthListOfPatternStringUnconstrained>
|
429 506 | for crate::model::LengthListOfPatternString
|
430 507 | {
|
508 + | /* UnconstrainedCollectionGenerator.kt:98 */
|
431 509 | type Error = crate::model::length_list_of_pattern_string_internal::ConstraintViolation;
|
510 + | /* UnconstrainedCollectionGenerator.kt:100 */
|
432 511 | fn try_from(
|
433 512 | value: LengthListOfPatternStringUnconstrained,
|
434 513 | ) -> std::result::Result<Self, Self::Error> {
|
514 + | /* UnconstrainedCollectionGenerator.kt:127 */
|
435 515 | let res: ::std::result::Result<
|
436 516 | ::std::vec::Vec<crate::model::PatternString>,
|
437 517 | (
|
438 518 | usize,
|
439 519 | crate::model::pattern_string_internal::ConstraintViolation,
|
440 520 | ),
|
441 521 | > = value
|
442 522 | .0
|
443 523 | .into_iter()
|
444 524 | .enumerate()
|
445 525 | .map(|(idx, inner)| {
|
446 526 | inner
|
447 527 | .try_into()
|
448 528 | .map_err(|inner_violation| (idx, inner_violation))
|
449 529 | })
|
450 530 | .collect();
|
451 531 | let inner =
|
452 532 | res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
|
533 + | /* UnconstrainedCollectionGenerator.kt:189 */
|
453 534 | Self::try_from(inner)
|
535 + | /* UnconstrainedCollectionGenerator.kt:100 */
|
454 536 | }
|
537 + | /* UnconstrainedCollectionGenerator.kt:97 */
|
455 538 | }
|
539 + |
|
540 + | /* RustCrateInlineModuleComposingWriter.kt:299 */
|
456 541 | }
|
457 542 | pub(crate) mod map_of_set_of_length_string_unconstrained {
|
458 543 |
|
544 + | /* UnconstrainedMapGenerator.kt:79 */
|
459 545 | #[derive(Debug, Clone)]
|
460 546 | pub(crate) struct MapOfSetOfLengthStringUnconstrained(pub(crate) std::collections::HashMap<::std::string::String, crate::unconstrained::set_of_length_string_unconstrained::SetOfLengthStringUnconstrained>);
|
461 547 |
|
462 548 | impl From<MapOfSetOfLengthStringUnconstrained> for crate::constrained::MaybeConstrained<crate::constrained::map_of_set_of_length_string_constrained::MapOfSetOfLengthStringConstrained> {
|
463 549 | fn from(value: MapOfSetOfLengthStringUnconstrained) -> Self {
|
464 550 | Self::Unconstrained(value)
|
465 551 | }
|
466 552 | }
|
553 + | /* UnconstrainedMapGenerator.kt:101 */
|
467 554 | impl std::convert::TryFrom<MapOfSetOfLengthStringUnconstrained> for crate::constrained::map_of_set_of_length_string_constrained::MapOfSetOfLengthStringConstrained {
|
468 - | type Error = crate::model::map_of_set_of_length_string_internal::ConstraintViolation;
|
469 - | fn try_from(value: MapOfSetOfLengthStringUnconstrained) -> std::result::Result<Self, Self::Error> {
|
470 - | let res: ::std::result::Result<::std::collections::HashMap<crate::model::LengthString, crate::model::SetOfLengthString>, Self::Error> = value.0
|
555 + | /* UnconstrainedMapGenerator.kt:102 */type Error = crate::model::map_of_set_of_length_string_internal::ConstraintViolation;
|
556 + | /* UnconstrainedMapGenerator.kt:104 */fn try_from(value: MapOfSetOfLengthStringUnconstrained) -> std::result::Result<Self, Self::Error> {
|
557 + | /* UnconstrainedMapGenerator.kt:186 */let res: ::std::result::Result<::std::collections::HashMap<crate::model::LengthString, crate::model::SetOfLengthString>, Self::Error> = value.0
|
471 558 | .into_iter()
|
472 559 | .map(|(k, v)| {
|
473 560 | let k: crate::model::LengthString = k.try_into().map_err(Self::Error::Key)?;
|
474 561 |
|
475 562 | match crate::model::SetOfLengthString::try_from(v) {
|
476 563 | Ok(v) => Ok((k, v)),
|
477 564 | Err(inner_constraint_violation) => Err(Self::Error::Value(k, inner_constraint_violation)),
|
478 565 | }
|
479 566 | })
|
480 567 | .collect();
|
481 568 | let hm = res?;
|
482 - | Ok(Self(hm))
|
483 - | }
|
484 - | }
|
569 + | /* UnconstrainedMapGenerator.kt:247 */Ok(Self(hm))
|
570 + | /* UnconstrainedMapGenerator.kt:104 */}
|
571 + | /* UnconstrainedMapGenerator.kt:101 */}
|
572 + |
|
573 + | /* RustCrateInlineModuleComposingWriter.kt:299 */
|
485 574 | }
|
486 575 | pub(crate) mod set_of_length_string_unconstrained {
|
487 576 |
|
577 + | /* UnconstrainedCollectionGenerator.kt:77 */
|
488 578 | #[derive(Debug, Clone)]
|
489 579 | pub(crate) struct SetOfLengthStringUnconstrained(
|
490 580 | pub(crate) std::vec::Vec<::std::string::String>,
|
491 581 | );
|
492 582 |
|
493 583 | impl From<SetOfLengthStringUnconstrained>
|
494 584 | for crate::constrained::MaybeConstrained<crate::model::SetOfLengthString>
|
495 585 | {
|
496 586 | fn from(value: SetOfLengthStringUnconstrained) -> Self {
|
497 587 | Self::Unconstrained(value)
|
498 588 | }
|
499 589 | }
|
590 + | /* UnconstrainedCollectionGenerator.kt:97 */
|
500 591 | impl std::convert::TryFrom<SetOfLengthStringUnconstrained> for crate::model::SetOfLengthString {
|
592 + | /* UnconstrainedCollectionGenerator.kt:98 */
|
501 593 | type Error = crate::model::set_of_length_string_internal::ConstraintViolation;
|
594 + | /* UnconstrainedCollectionGenerator.kt:100 */
|
502 595 | fn try_from(
|
503 596 | value: SetOfLengthStringUnconstrained,
|
504 597 | ) -> std::result::Result<Self, Self::Error> {
|
598 + | /* UnconstrainedCollectionGenerator.kt:127 */
|
505 599 | let res: ::std::result::Result<
|
506 600 | ::std::vec::Vec<crate::model::LengthString>,
|
507 601 | (
|
508 602 | usize,
|
509 603 | crate::model::length_string_internal::ConstraintViolation,
|
510 604 | ),
|
511 605 | > = value
|
512 606 | .0
|
513 607 | .into_iter()
|
514 608 | .enumerate()
|
515 609 | .map(|(idx, inner)| {
|
516 610 | inner
|
517 611 | .try_into()
|
518 612 | .map_err(|inner_violation| (idx, inner_violation))
|
519 613 | })
|
520 614 | .collect();
|
521 615 | let inner =
|
522 616 | res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
|
617 + | /* UnconstrainedCollectionGenerator.kt:189 */
|
523 618 | Self::try_from(inner)
|
619 + | /* UnconstrainedCollectionGenerator.kt:100 */
|
524 620 | }
|
621 + | /* UnconstrainedCollectionGenerator.kt:97 */
|
525 622 | }
|
623 + |
|
624 + | /* RustCrateInlineModuleComposingWriter.kt:299 */
|
526 625 | }
|
527 626 | pub(crate) mod map_of_list_of_length_string_unconstrained {
|
528 627 |
|
628 + | /* UnconstrainedMapGenerator.kt:79 */
|
529 629 | #[derive(Debug, Clone)]
|
530 630 | pub(crate) struct MapOfListOfLengthStringUnconstrained(pub(crate) std::collections::HashMap<::std::string::String, crate::unconstrained::list_of_length_string_unconstrained::ListOfLengthStringUnconstrained>);
|
531 631 |
|
532 632 | impl From<MapOfListOfLengthStringUnconstrained> for crate::constrained::MaybeConstrained<crate::constrained::map_of_list_of_length_string_constrained::MapOfListOfLengthStringConstrained> {
|
533 633 | fn from(value: MapOfListOfLengthStringUnconstrained) -> Self {
|
534 634 | Self::Unconstrained(value)
|
535 635 | }
|
536 636 | }
|
637 + | /* UnconstrainedMapGenerator.kt:101 */
|
537 638 | impl std::convert::TryFrom<MapOfListOfLengthStringUnconstrained> for crate::constrained::map_of_list_of_length_string_constrained::MapOfListOfLengthStringConstrained {
|
538 - | type Error = crate::model::map_of_list_of_length_string_internal::ConstraintViolation;
|
539 - | fn try_from(value: MapOfListOfLengthStringUnconstrained) -> std::result::Result<Self, Self::Error> {
|
540 - | let res: ::std::result::Result<::std::collections::HashMap<crate::model::LengthString, crate::constrained::list_of_length_string_constrained::ListOfLengthStringConstrained>, Self::Error> = value.0
|
639 + | /* UnconstrainedMapGenerator.kt:102 */type Error = crate::model::map_of_list_of_length_string_internal::ConstraintViolation;
|
640 + | /* UnconstrainedMapGenerator.kt:104 */fn try_from(value: MapOfListOfLengthStringUnconstrained) -> std::result::Result<Self, Self::Error> {
|
641 + | /* UnconstrainedMapGenerator.kt:186 */let res: ::std::result::Result<::std::collections::HashMap<crate::model::LengthString, crate::constrained::list_of_length_string_constrained::ListOfLengthStringConstrained>, Self::Error> = value.0
|
541 642 | .into_iter()
|
542 643 | .map(|(k, v)| {
|
543 644 | let k: crate::model::LengthString = k.try_into().map_err(Self::Error::Key)?;
|
544 645 |
|
545 646 | match crate::constrained::list_of_length_string_constrained::ListOfLengthStringConstrained::try_from(v) {
|
546 647 | Ok(v) => Ok((k, v)),
|
547 648 | Err(inner_constraint_violation) => Err(Self::Error::Value(k, inner_constraint_violation)),
|
548 649 | }
|
549 650 | })
|
550 651 | .collect();
|
551 652 | let hm = res?;
|
552 - | Ok(Self(hm))
|
553 - | }
|
554 - | }
|
653 + | /* UnconstrainedMapGenerator.kt:247 */Ok(Self(hm))
|
654 + | /* UnconstrainedMapGenerator.kt:104 */}
|
655 + | /* UnconstrainedMapGenerator.kt:101 */}
|
656 + |
|
657 + | /* RustCrateInlineModuleComposingWriter.kt:299 */
|
555 658 | }
|
556 659 | pub(crate) mod list_of_length_string_unconstrained {
|
557 660 |
|
661 + | /* UnconstrainedCollectionGenerator.kt:77 */
|
558 662 | #[derive(Debug, Clone)]
|
559 663 | pub(crate) struct ListOfLengthStringUnconstrained(
|
560 664 | pub(crate) std::vec::Vec<::std::string::String>,
|
561 665 | );
|
562 666 |
|
563 667 | impl From<ListOfLengthStringUnconstrained>
|
564 668 | for crate::constrained::MaybeConstrained<
|
565 669 | crate::constrained::list_of_length_string_constrained::ListOfLengthStringConstrained,
|
566 670 | >
|
567 671 | {
|
568 672 | fn from(value: ListOfLengthStringUnconstrained) -> Self {
|
569 673 | Self::Unconstrained(value)
|
570 674 | }
|
571 675 | }
|
676 + | /* UnconstrainedCollectionGenerator.kt:97 */
|
572 677 | impl std::convert::TryFrom<ListOfLengthStringUnconstrained>
|
573 678 | for crate::constrained::list_of_length_string_constrained::ListOfLengthStringConstrained
|
574 679 | {
|
680 + | /* UnconstrainedCollectionGenerator.kt:98 */
|
575 681 | type Error = crate::model::list_of_length_string_internal::ConstraintViolation;
|
682 + | /* UnconstrainedCollectionGenerator.kt:100 */
|
576 683 | fn try_from(
|
577 684 | value: ListOfLengthStringUnconstrained,
|
578 685 | ) -> std::result::Result<Self, Self::Error> {
|
686 + | /* UnconstrainedCollectionGenerator.kt:127 */
|
579 687 | let res: ::std::result::Result<
|
580 688 | ::std::vec::Vec<crate::model::LengthString>,
|
581 689 | (
|
582 690 | usize,
|
583 691 | crate::model::length_string_internal::ConstraintViolation,
|
584 692 | ),
|
585 693 | > = value
|
586 694 | .0
|
587 695 | .into_iter()
|
588 696 | .enumerate()
|
589 697 | .map(|(idx, inner)| {
|
590 698 | inner
|
591 699 | .try_into()
|
592 700 | .map_err(|inner_violation| (idx, inner_violation))
|
593 701 | })
|
594 702 | .collect();
|
595 703 | let inner =
|
596 704 | res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
|
705 + | /* UnconstrainedCollectionGenerator.kt:191 */
|
597 706 | Ok(Self(inner))
|
707 + | /* UnconstrainedCollectionGenerator.kt:100 */
|
598 708 | }
|
709 + | /* UnconstrainedCollectionGenerator.kt:97 */
|
599 710 | }
|
711 + |
|
712 + | /* RustCrateInlineModuleComposingWriter.kt:299 */
|
600 713 | }
|
601 714 | pub(crate) mod map_of_length_string_unconstrained {
|
602 715 |
|
716 + | /* UnconstrainedMapGenerator.kt:79 */
|
603 717 | #[derive(Debug, Clone)]
|
604 718 | pub(crate) struct MapOfLengthStringUnconstrained(
|
605 719 | pub(crate) std::collections::HashMap<::std::string::String, ::std::string::String>,
|
606 720 | );
|
607 721 |
|
608 722 | impl From<MapOfLengthStringUnconstrained>
|
609 723 | for crate::constrained::MaybeConstrained<
|
610 724 | crate::constrained::map_of_length_string_constrained::MapOfLengthStringConstrained,
|
611 725 | >
|
612 726 | {
|
613 727 | fn from(value: MapOfLengthStringUnconstrained) -> Self {
|
614 728 | Self::Unconstrained(value)
|
615 729 | }
|
616 730 | }
|
731 + | /* UnconstrainedMapGenerator.kt:101 */
|
617 732 | impl std::convert::TryFrom<MapOfLengthStringUnconstrained>
|
618 733 | for crate::constrained::map_of_length_string_constrained::MapOfLengthStringConstrained
|
619 734 | {
|
735 + | /* UnconstrainedMapGenerator.kt:102 */
|
620 736 | type Error = crate::model::map_of_length_string_internal::ConstraintViolation;
|
737 + | /* UnconstrainedMapGenerator.kt:104 */
|
621 738 | fn try_from(
|
622 739 | value: MapOfLengthStringUnconstrained,
|
623 740 | ) -> std::result::Result<Self, Self::Error> {
|
741 + | /* UnconstrainedMapGenerator.kt:186 */
|
624 742 | let res: ::std::result::Result<
|
625 743 | ::std::collections::HashMap<crate::model::LengthString, crate::model::LengthString>,
|
626 744 | Self::Error,
|
627 745 | > = value
|
628 746 | .0
|
629 747 | .into_iter()
|
630 748 | .map(|(k, v)| {
|
631 749 | let k: crate::model::LengthString = k.try_into().map_err(Self::Error::Key)?;
|
632 750 |
|
633 751 | match crate::model::LengthString::try_from(v) {
|
634 752 | Ok(v) => Ok((k, v)),
|
635 753 | Err(inner_constraint_violation) => {
|
636 754 | Err(Self::Error::Value(k, inner_constraint_violation))
|
637 755 | }
|
638 756 | }
|
639 757 | })
|
640 758 | .collect();
|
641 759 | let hm = res?;
|
760 + | /* UnconstrainedMapGenerator.kt:247 */
|
642 761 | Ok(Self(hm))
|
762 + | /* UnconstrainedMapGenerator.kt:104 */
|
643 763 | }
|
764 + | /* UnconstrainedMapGenerator.kt:101 */
|
644 765 | }
|
766 + |
|
767 + | /* RustCrateInlineModuleComposingWriter.kt:299 */
|
645 768 | }
|
646 769 | pub(crate) mod recursive_list_unconstrained {
|
647 770 |
|
771 + | /* UnconstrainedCollectionGenerator.kt:77 */
|
648 772 | #[derive(Debug, Clone)]
|
649 773 | pub(crate) struct RecursiveListUnconstrained(
|
650 774 | pub(crate)
|
651 775 | std::vec::Vec<crate::model::recursive_shapes_input_output_nested1_internal::Builder>,
|
652 776 | );
|
653 777 |
|
654 778 | impl From<RecursiveListUnconstrained>
|
655 779 | for crate::constrained::MaybeConstrained<
|
656 780 | crate::constrained::recursive_list_constrained::RecursiveListConstrained,
|
657 781 | >
|
658 782 | {
|
659 783 | fn from(value: RecursiveListUnconstrained) -> Self {
|
660 784 | Self::Unconstrained(value)
|
661 785 | }
|
662 786 | }
|
787 + | /* UnconstrainedCollectionGenerator.kt:97 */
|
663 788 | impl std::convert::TryFrom<RecursiveListUnconstrained>
|
664 789 | for crate::constrained::recursive_list_constrained::RecursiveListConstrained
|
665 790 | {
|
791 + | /* UnconstrainedCollectionGenerator.kt:98 */
|
666 792 | type Error = crate::model::recursive_list_internal::ConstraintViolation;
|
793 + | /* UnconstrainedCollectionGenerator.kt:100 */
|
667 794 | fn try_from(value: RecursiveListUnconstrained) -> std::result::Result<Self, Self::Error> {
|
795 + | /* UnconstrainedCollectionGenerator.kt:127 */
|
668 796 | let res: ::std::result::Result<::std::vec::Vec<crate::model::RecursiveShapesInputOutputNested1>, (usize, crate::model::recursive_shapes_input_output_nested1_internal::ConstraintViolation) > = value
|
669 797 | .0
|
670 798 | .into_iter()
|
671 799 | .enumerate()
|
672 800 | .map(|(idx, inner)| {
|
673 801 | inner.try_into().map_err(|inner_violation| (idx, inner_violation))
|
674 802 | })
|
675 803 | .collect();
|
676 804 | let inner =
|
677 805 | res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
|
806 + | /* UnconstrainedCollectionGenerator.kt:191 */
|
678 807 | Ok(Self(inner))
|
808 + | /* UnconstrainedCollectionGenerator.kt:100 */
|
679 809 | }
|
810 + | /* UnconstrainedCollectionGenerator.kt:97 */
|
680 811 | }
|
812 + |
|
813 + | /* RustCrateInlineModuleComposingWriter.kt:299 */
|
681 814 | }
|
682 815 | pub(crate) mod length_set_of_pattern_string_unconstrained {
|
683 816 |
|
817 + | /* UnconstrainedCollectionGenerator.kt:77 */
|
684 818 | #[derive(Debug, Clone)]
|
685 819 | pub(crate) struct LengthSetOfPatternStringUnconstrained(
|
686 820 | pub(crate) std::vec::Vec<::std::string::String>,
|
687 821 | );
|
688 822 |
|
689 823 | impl From<LengthSetOfPatternStringUnconstrained>
|
690 824 | for crate::constrained::MaybeConstrained<crate::model::LengthSetOfPatternString>
|
691 825 | {
|
692 826 | fn from(value: LengthSetOfPatternStringUnconstrained) -> Self {
|
693 827 | Self::Unconstrained(value)
|
694 828 | }
|
695 829 | }
|
830 + | /* UnconstrainedCollectionGenerator.kt:97 */
|
696 831 | impl std::convert::TryFrom<LengthSetOfPatternStringUnconstrained>
|
697 832 | for crate::model::LengthSetOfPatternString
|
698 833 | {
|
834 + | /* UnconstrainedCollectionGenerator.kt:98 */
|
699 835 | type Error = crate::model::length_set_of_pattern_string_internal::ConstraintViolation;
|
836 + | /* UnconstrainedCollectionGenerator.kt:100 */
|
700 837 | fn try_from(
|
701 838 | value: LengthSetOfPatternStringUnconstrained,
|
702 839 | ) -> std::result::Result<Self, Self::Error> {
|
840 + | /* UnconstrainedCollectionGenerator.kt:127 */
|
703 841 | let res: ::std::result::Result<
|
704 842 | ::std::vec::Vec<crate::model::PatternString>,
|
705 843 | (
|
706 844 | usize,
|
707 845 | crate::model::pattern_string_internal::ConstraintViolation,
|
708 846 | ),
|
709 847 | > = value
|
710 848 | .0
|
711 849 | .into_iter()
|
712 850 | .enumerate()
|
713 851 | .map(|(idx, inner)| {
|
714 852 | inner
|
715 853 | .try_into()
|
716 854 | .map_err(|inner_violation| (idx, inner_violation))
|
717 855 | })
|
718 856 | .collect();
|
719 857 | let inner =
|
720 858 | res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
|
859 + | /* UnconstrainedCollectionGenerator.kt:189 */
|
721 860 | Self::try_from(inner)
|
861 + | /* UnconstrainedCollectionGenerator.kt:100 */
|
722 862 | }
|
863 + | /* UnconstrainedCollectionGenerator.kt:97 */
|
723 864 | }
|
865 + |
|
866 + | /* RustCrateInlineModuleComposingWriter.kt:299 */
|
724 867 | }
|
725 868 | pub(crate) mod set_of_length_pattern_string_unconstrained {
|
726 869 |
|
870 + | /* UnconstrainedCollectionGenerator.kt:77 */
|
727 871 | #[derive(Debug, Clone)]
|
728 872 | pub(crate) struct SetOfLengthPatternStringUnconstrained(
|
729 873 | pub(crate) std::vec::Vec<::std::string::String>,
|
730 874 | );
|
731 875 |
|
732 876 | impl From<SetOfLengthPatternStringUnconstrained>
|
733 877 | for crate::constrained::MaybeConstrained<crate::model::SetOfLengthPatternString>
|
734 878 | {
|
735 879 | fn from(value: SetOfLengthPatternStringUnconstrained) -> Self {
|
736 880 | Self::Unconstrained(value)
|
737 881 | }
|
738 882 | }
|
883 + | /* UnconstrainedCollectionGenerator.kt:97 */
|
739 884 | impl std::convert::TryFrom<SetOfLengthPatternStringUnconstrained>
|
740 885 | for crate::model::SetOfLengthPatternString
|
741 886 | {
|
887 + | /* UnconstrainedCollectionGenerator.kt:98 */
|
742 888 | type Error = crate::model::set_of_length_pattern_string_internal::ConstraintViolation;
|
889 + | /* UnconstrainedCollectionGenerator.kt:100 */
|
743 890 | fn try_from(
|
744 891 | value: SetOfLengthPatternStringUnconstrained,
|
745 892 | ) -> std::result::Result<Self, Self::Error> {
|
893 + | /* UnconstrainedCollectionGenerator.kt:127 */
|
746 894 | let res: ::std::result::Result<
|
747 895 | ::std::vec::Vec<crate::model::LengthPatternString>,
|
748 896 | (
|
749 897 | usize,
|
750 898 | crate::model::length_pattern_string_internal::ConstraintViolation,
|
751 899 | ),
|
752 900 | > = value
|
753 901 | .0
|
754 902 | .into_iter()
|
755 903 | .enumerate()
|
756 904 | .map(|(idx, inner)| {
|
757 905 | inner
|
758 906 | .try_into()
|
759 907 | .map_err(|inner_violation| (idx, inner_violation))
|
760 908 | })
|
761 909 | .collect();
|
762 910 | let inner =
|
763 911 | res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
|
912 + | /* UnconstrainedCollectionGenerator.kt:189 */
|
764 913 | Self::try_from(inner)
|
914 + | /* UnconstrainedCollectionGenerator.kt:100 */
|
765 915 | }
|
916 + | /* UnconstrainedCollectionGenerator.kt:97 */
|
766 917 | }
|
918 + |
|
919 + | /* RustCrateInlineModuleComposingWriter.kt:299 */
|
767 920 | }
|
768 921 | pub(crate) mod set_of_pattern_string_unconstrained {
|
769 922 |
|
923 + | /* UnconstrainedCollectionGenerator.kt:77 */
|
770 924 | #[derive(Debug, Clone)]
|
771 925 | pub(crate) struct SetOfPatternStringUnconstrained(
|
772 926 | pub(crate) std::vec::Vec<::std::string::String>,
|
773 927 | );
|
774 928 |
|
775 929 | impl From<SetOfPatternStringUnconstrained>
|
776 930 | for crate::constrained::MaybeConstrained<crate::model::SetOfPatternString>
|
777 931 | {
|
778 932 | fn from(value: SetOfPatternStringUnconstrained) -> Self {
|
779 933 | Self::Unconstrained(value)
|
780 934 | }
|
781 935 | }
|
936 + | /* UnconstrainedCollectionGenerator.kt:97 */
|
782 937 | impl std::convert::TryFrom<SetOfPatternStringUnconstrained> for crate::model::SetOfPatternString {
|
938 + | /* UnconstrainedCollectionGenerator.kt:98 */
|
783 939 | type Error = crate::model::set_of_pattern_string_internal::ConstraintViolation;
|
940 + | /* UnconstrainedCollectionGenerator.kt:100 */
|
784 941 | fn try_from(
|
785 942 | value: SetOfPatternStringUnconstrained,
|
786 943 | ) -> std::result::Result<Self, Self::Error> {
|
944 + | /* UnconstrainedCollectionGenerator.kt:127 */
|
787 945 | let res: ::std::result::Result<
|
788 946 | ::std::vec::Vec<crate::model::PatternString>,
|
789 947 | (
|
790 948 | usize,
|
791 949 | crate::model::pattern_string_internal::ConstraintViolation,
|
792 950 | ),
|
793 951 | > = value
|
794 952 | .0
|
795 953 | .into_iter()
|
796 954 | .enumerate()
|
797 955 | .map(|(idx, inner)| {
|
798 956 | inner
|
799 957 | .try_into()
|
800 958 | .map_err(|inner_violation| (idx, inner_violation))
|
801 959 | })
|
802 960 | .collect();
|
803 961 | let inner =
|
804 962 | res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
|
963 + | /* UnconstrainedCollectionGenerator.kt:189 */
|
805 964 | Self::try_from(inner)
|
965 + | /* UnconstrainedCollectionGenerator.kt:100 */
|
806 966 | }
|
967 + | /* UnconstrainedCollectionGenerator.kt:97 */
|
807 968 | }
|
969 + |
|
970 + | /* RustCrateInlineModuleComposingWriter.kt:299 */
|
808 971 | }
|
809 972 | pub(crate) mod map_of_range_byte_unconstrained {
|
810 973 |
|
974 + | /* UnconstrainedMapGenerator.kt:79 */
|
811 975 | #[derive(Debug, Clone)]
|
812 976 | pub(crate) struct MapOfRangeByteUnconstrained(
|
813 977 | pub(crate) std::collections::HashMap<::std::string::String, i8>,
|
814 978 | );
|
815 979 |
|
816 980 | impl From<MapOfRangeByteUnconstrained>
|
817 981 | for crate::constrained::MaybeConstrained<
|
818 982 | crate::constrained::map_of_range_byte_constrained::MapOfRangeByteConstrained,
|
819 983 | >
|
820 984 | {
|
821 985 | fn from(value: MapOfRangeByteUnconstrained) -> Self {
|
822 986 | Self::Unconstrained(value)
|
823 987 | }
|
824 988 | }
|
989 + | /* UnconstrainedMapGenerator.kt:101 */
|
825 990 | impl std::convert::TryFrom<MapOfRangeByteUnconstrained>
|
826 991 | for crate::constrained::map_of_range_byte_constrained::MapOfRangeByteConstrained
|
827 992 | {
|
993 + | /* UnconstrainedMapGenerator.kt:102 */
|
828 994 | type Error = crate::model::map_of_range_byte_internal::ConstraintViolation;
|
995 + | /* UnconstrainedMapGenerator.kt:104 */
|
829 996 | fn try_from(value: MapOfRangeByteUnconstrained) -> std::result::Result<Self, Self::Error> {
|
997 + | /* UnconstrainedMapGenerator.kt:186 */
|
830 998 | let res: ::std::result::Result<
|
831 999 | ::std::collections::HashMap<::std::string::String, crate::model::RangeByte>,
|
832 1000 | Self::Error,
|
833 1001 | > = value
|
834 1002 | .0
|
835 1003 | .into_iter()
|
836 1004 | .map(|(k, v)| match crate::model::RangeByte::try_from(v) {
|
837 1005 | Ok(v) => Ok((k, v)),
|
838 1006 | Err(inner_constraint_violation) => {
|
839 1007 | Err(Self::Error::Value(k, inner_constraint_violation))
|
840 1008 | }
|
841 1009 | })
|
842 1010 | .collect();
|
843 1011 | let hm = res?;
|
1012 + | /* UnconstrainedMapGenerator.kt:247 */
|
844 1013 | Ok(Self(hm))
|
1014 + | /* UnconstrainedMapGenerator.kt:104 */
|
845 1015 | }
|
1016 + | /* UnconstrainedMapGenerator.kt:101 */
|
846 1017 | }
|
1018 + |
|
1019 + | /* RustCrateInlineModuleComposingWriter.kt:299 */
|
847 1020 | }
|
848 1021 | pub(crate) mod set_of_range_byte_unconstrained {
|
849 1022 |
|
1023 + | /* UnconstrainedCollectionGenerator.kt:77 */
|
850 1024 | #[derive(Debug, Clone)]
|
851 1025 | pub(crate) struct SetOfRangeByteUnconstrained(pub(crate) std::vec::Vec<i8>);
|
852 1026 |
|
853 1027 | impl From<SetOfRangeByteUnconstrained>
|
854 1028 | for crate::constrained::MaybeConstrained<crate::model::SetOfRangeByte>
|
855 1029 | {
|
856 1030 | fn from(value: SetOfRangeByteUnconstrained) -> Self {
|
857 1031 | Self::Unconstrained(value)
|
858 1032 | }
|
859 1033 | }
|
1034 + | /* UnconstrainedCollectionGenerator.kt:97 */
|
860 1035 | impl std::convert::TryFrom<SetOfRangeByteUnconstrained> for crate::model::SetOfRangeByte {
|
1036 + | /* UnconstrainedCollectionGenerator.kt:98 */
|
861 1037 | type Error = crate::model::set_of_range_byte_internal::ConstraintViolation;
|
1038 + | /* UnconstrainedCollectionGenerator.kt:100 */
|
862 1039 | fn try_from(value: SetOfRangeByteUnconstrained) -> std::result::Result<Self, Self::Error> {
|
1040 + | /* UnconstrainedCollectionGenerator.kt:127 */
|
863 1041 | let res: ::std::result::Result<
|
864 1042 | ::std::vec::Vec<crate::model::RangeByte>,
|
865 1043 | (
|
866 1044 | usize,
|
867 1045 | crate::model::range_byte_internal::ConstraintViolation,
|
868 1046 | ),
|
869 1047 | > = value
|
870 1048 | .0
|
871 1049 | .into_iter()
|
872 1050 | .enumerate()
|
873 1051 | .map(|(idx, inner)| {
|
874 1052 | inner
|
875 1053 | .try_into()
|
876 1054 | .map_err(|inner_violation| (idx, inner_violation))
|
877 1055 | })
|
878 1056 | .collect();
|
879 1057 | let inner =
|
880 1058 | res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
|
1059 + | /* UnconstrainedCollectionGenerator.kt:189 */
|
881 1060 | Self::try_from(inner)
|
1061 + | /* UnconstrainedCollectionGenerator.kt:100 */
|
882 1062 | }
|
1063 + | /* UnconstrainedCollectionGenerator.kt:97 */
|
883 1064 | }
|
1065 + |
|
1066 + | /* RustCrateInlineModuleComposingWriter.kt:299 */
|
884 1067 | }
|
885 1068 | pub(crate) mod list_of_range_byte_unconstrained {
|
886 1069 |
|
1070 + | /* UnconstrainedCollectionGenerator.kt:77 */
|
887 1071 | #[derive(Debug, Clone)]
|
888 1072 | pub(crate) struct ListOfRangeByteUnconstrained(pub(crate) std::vec::Vec<i8>);
|
889 1073 |
|
890 1074 | impl From<ListOfRangeByteUnconstrained>
|
891 1075 | for crate::constrained::MaybeConstrained<
|
892 1076 | crate::constrained::list_of_range_byte_constrained::ListOfRangeByteConstrained,
|
893 1077 | >
|
894 1078 | {
|
895 1079 | fn from(value: ListOfRangeByteUnconstrained) -> Self {
|
896 1080 | Self::Unconstrained(value)
|
897 1081 | }
|
898 1082 | }
|
1083 + | /* UnconstrainedCollectionGenerator.kt:97 */
|
899 1084 | impl std::convert::TryFrom<ListOfRangeByteUnconstrained>
|
900 1085 | for crate::constrained::list_of_range_byte_constrained::ListOfRangeByteConstrained
|
901 1086 | {
|
1087 + | /* UnconstrainedCollectionGenerator.kt:98 */
|
902 1088 | type Error = crate::model::list_of_range_byte_internal::ConstraintViolation;
|
1089 + | /* UnconstrainedCollectionGenerator.kt:100 */
|
903 1090 | fn try_from(value: ListOfRangeByteUnconstrained) -> std::result::Result<Self, Self::Error> {
|
1091 + | /* UnconstrainedCollectionGenerator.kt:127 */
|
904 1092 | let res: ::std::result::Result<
|
905 1093 | ::std::vec::Vec<crate::model::RangeByte>,
|
906 1094 | (
|
907 1095 | usize,
|
908 1096 | crate::model::range_byte_internal::ConstraintViolation,
|
909 1097 | ),
|
910 1098 | > = value
|
911 1099 | .0
|
912 1100 | .into_iter()
|
913 1101 | .enumerate()
|
914 1102 | .map(|(idx, inner)| {
|
915 1103 | inner
|
916 1104 | .try_into()
|
917 1105 | .map_err(|inner_violation| (idx, inner_violation))
|
918 1106 | })
|
919 1107 | .collect();
|
920 1108 | let inner =
|
921 1109 | res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
|
1110 + | /* UnconstrainedCollectionGenerator.kt:191 */
|
922 1111 | Ok(Self(inner))
|
1112 + | /* UnconstrainedCollectionGenerator.kt:100 */
|
923 1113 | }
|
1114 + | /* UnconstrainedCollectionGenerator.kt:97 */
|
924 1115 | }
|
1116 + |
|
1117 + | /* RustCrateInlineModuleComposingWriter.kt:299 */
|
925 1118 | }
|
926 1119 | pub(crate) mod map_of_range_long_unconstrained {
|
927 1120 |
|
1121 + | /* UnconstrainedMapGenerator.kt:79 */
|
928 1122 | #[derive(Debug, Clone)]
|
929 1123 | pub(crate) struct MapOfRangeLongUnconstrained(
|
930 1124 | pub(crate) std::collections::HashMap<::std::string::String, i64>,
|
931 1125 | );
|
932 1126 |
|
933 1127 | impl From<MapOfRangeLongUnconstrained>
|
934 1128 | for crate::constrained::MaybeConstrained<
|
935 1129 | crate::constrained::map_of_range_long_constrained::MapOfRangeLongConstrained,
|
936 1130 | >
|
937 1131 | {
|
938 1132 | fn from(value: MapOfRangeLongUnconstrained) -> Self {
|
939 1133 | Self::Unconstrained(value)
|
940 1134 | }
|
941 1135 | }
|
1136 + | /* UnconstrainedMapGenerator.kt:101 */
|
942 1137 | impl std::convert::TryFrom<MapOfRangeLongUnconstrained>
|
943 1138 | for crate::constrained::map_of_range_long_constrained::MapOfRangeLongConstrained
|
944 1139 | {
|
1140 + | /* UnconstrainedMapGenerator.kt:102 */
|
945 1141 | type Error = crate::model::map_of_range_long_internal::ConstraintViolation;
|
1142 + | /* UnconstrainedMapGenerator.kt:104 */
|
946 1143 | fn try_from(value: MapOfRangeLongUnconstrained) -> std::result::Result<Self, Self::Error> {
|
1144 + | /* UnconstrainedMapGenerator.kt:186 */
|
947 1145 | let res: ::std::result::Result<
|
948 1146 | ::std::collections::HashMap<::std::string::String, crate::model::RangeLong>,
|
949 1147 | Self::Error,
|
950 1148 | > = value
|
951 1149 | .0
|
952 1150 | .into_iter()
|
953 1151 | .map(|(k, v)| match crate::model::RangeLong::try_from(v) {
|
954 1152 | Ok(v) => Ok((k, v)),
|
955 1153 | Err(inner_constraint_violation) => {
|
956 1154 | Err(Self::Error::Value(k, inner_constraint_violation))
|
957 1155 | }
|
958 1156 | })
|
959 1157 | .collect();
|
960 1158 | let hm = res?;
|
1159 + | /* UnconstrainedMapGenerator.kt:247 */
|
961 1160 | Ok(Self(hm))
|
1161 + | /* UnconstrainedMapGenerator.kt:104 */
|
962 1162 | }
|
1163 + | /* UnconstrainedMapGenerator.kt:101 */
|
963 1164 | }
|
1165 + |
|
1166 + | /* RustCrateInlineModuleComposingWriter.kt:299 */
|
964 1167 | }
|
965 1168 | pub(crate) mod set_of_range_long_unconstrained {
|
966 1169 |
|
1170 + | /* UnconstrainedCollectionGenerator.kt:77 */
|
967 1171 | #[derive(Debug, Clone)]
|
968 1172 | pub(crate) struct SetOfRangeLongUnconstrained(pub(crate) std::vec::Vec<i64>);
|
969 1173 |
|
970 1174 | impl From<SetOfRangeLongUnconstrained>
|
971 1175 | for crate::constrained::MaybeConstrained<crate::model::SetOfRangeLong>
|
972 1176 | {
|
973 1177 | fn from(value: SetOfRangeLongUnconstrained) -> Self {
|
974 1178 | Self::Unconstrained(value)
|
975 1179 | }
|
976 1180 | }
|
1181 + | /* UnconstrainedCollectionGenerator.kt:97 */
|
977 1182 | impl std::convert::TryFrom<SetOfRangeLongUnconstrained> for crate::model::SetOfRangeLong {
|
1183 + | /* UnconstrainedCollectionGenerator.kt:98 */
|
978 1184 | type Error = crate::model::set_of_range_long_internal::ConstraintViolation;
|
1185 + | /* UnconstrainedCollectionGenerator.kt:100 */
|
979 1186 | fn try_from(value: SetOfRangeLongUnconstrained) -> std::result::Result<Self, Self::Error> {
|
1187 + | /* UnconstrainedCollectionGenerator.kt:127 */
|
980 1188 | let res: ::std::result::Result<
|
981 1189 | ::std::vec::Vec<crate::model::RangeLong>,
|
982 1190 | (
|
983 1191 | usize,
|
984 1192 | crate::model::range_long_internal::ConstraintViolation,
|
985 1193 | ),
|
986 1194 | > = value
|
987 1195 | .0
|
988 1196 | .into_iter()
|
989 1197 | .enumerate()
|
990 1198 | .map(|(idx, inner)| {
|
991 1199 | inner
|
992 1200 | .try_into()
|
993 1201 | .map_err(|inner_violation| (idx, inner_violation))
|
994 1202 | })
|
995 1203 | .collect();
|
996 1204 | let inner =
|
997 1205 | res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
|
1206 + | /* UnconstrainedCollectionGenerator.kt:189 */
|
998 1207 | Self::try_from(inner)
|
1208 + | /* UnconstrainedCollectionGenerator.kt:100 */
|
999 1209 | }
|
1210 + | /* UnconstrainedCollectionGenerator.kt:97 */
|
1000 1211 | }
|
1212 + |
|
1213 + | /* RustCrateInlineModuleComposingWriter.kt:299 */
|
1001 1214 | }
|
1002 1215 | pub(crate) mod list_of_range_long_unconstrained {
|
1003 1216 |
|
1217 + | /* UnconstrainedCollectionGenerator.kt:77 */
|
1004 1218 | #[derive(Debug, Clone)]
|
1005 1219 | pub(crate) struct ListOfRangeLongUnconstrained(pub(crate) std::vec::Vec<i64>);
|
1006 1220 |
|
1007 1221 | impl From<ListOfRangeLongUnconstrained>
|
1008 1222 | for crate::constrained::MaybeConstrained<
|
1009 1223 | crate::constrained::list_of_range_long_constrained::ListOfRangeLongConstrained,
|
1010 1224 | >
|
1011 1225 | {
|
1012 1226 | fn from(value: ListOfRangeLongUnconstrained) -> Self {
|
1013 1227 | Self::Unconstrained(value)
|
1014 1228 | }
|
1015 1229 | }
|
1230 + | /* UnconstrainedCollectionGenerator.kt:97 */
|
1016 1231 | impl std::convert::TryFrom<ListOfRangeLongUnconstrained>
|
1017 1232 | for crate::constrained::list_of_range_long_constrained::ListOfRangeLongConstrained
|
1018 1233 | {
|
1234 + | /* UnconstrainedCollectionGenerator.kt:98 */
|
1019 1235 | type Error = crate::model::list_of_range_long_internal::ConstraintViolation;
|
1236 + | /* UnconstrainedCollectionGenerator.kt:100 */
|
1020 1237 | fn try_from(value: ListOfRangeLongUnconstrained) -> std::result::Result<Self, Self::Error> {
|
1238 + | /* UnconstrainedCollectionGenerator.kt:127 */
|
1021 1239 | let res: ::std::result::Result<
|
1022 1240 | ::std::vec::Vec<crate::model::RangeLong>,
|
1023 1241 | (
|
1024 1242 | usize,
|
1025 1243 | crate::model::range_long_internal::ConstraintViolation,
|
1026 1244 | ),
|
1027 1245 | > = value
|
1028 1246 | .0
|
1029 1247 | .into_iter()
|
1030 1248 | .enumerate()
|
1031 1249 | .map(|(idx, inner)| {
|
1032 1250 | inner
|
1033 1251 | .try_into()
|
1034 1252 | .map_err(|inner_violation| (idx, inner_violation))
|
1035 1253 | })
|
1036 1254 | .collect();
|
1037 1255 | let inner =
|
1038 1256 | res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
|
1257 + | /* UnconstrainedCollectionGenerator.kt:191 */
|
1039 1258 | Ok(Self(inner))
|
1259 + | /* UnconstrainedCollectionGenerator.kt:100 */
|
1040 1260 | }
|
1261 + | /* UnconstrainedCollectionGenerator.kt:97 */
|
1041 1262 | }
|
1263 + |
|
1264 + | /* RustCrateInlineModuleComposingWriter.kt:299 */
|
1042 1265 | }
|
1043 1266 | pub(crate) mod map_of_range_short_unconstrained {
|
1044 1267 |
|
1268 + | /* UnconstrainedMapGenerator.kt:79 */
|
1045 1269 | #[derive(Debug, Clone)]
|
1046 1270 | pub(crate) struct MapOfRangeShortUnconstrained(
|
1047 1271 | pub(crate) std::collections::HashMap<::std::string::String, i16>,
|
1048 1272 | );
|
1049 1273 |
|
1050 1274 | impl From<MapOfRangeShortUnconstrained>
|
1051 1275 | for crate::constrained::MaybeConstrained<
|
1052 1276 | crate::constrained::map_of_range_short_constrained::MapOfRangeShortConstrained,
|
1053 1277 | >
|
1054 1278 | {
|
1055 1279 | fn from(value: MapOfRangeShortUnconstrained) -> Self {
|
1056 1280 | Self::Unconstrained(value)
|
1057 1281 | }
|
1058 1282 | }
|
1283 + | /* UnconstrainedMapGenerator.kt:101 */
|
1059 1284 | impl std::convert::TryFrom<MapOfRangeShortUnconstrained>
|
1060 1285 | for crate::constrained::map_of_range_short_constrained::MapOfRangeShortConstrained
|
1061 1286 | {
|
1287 + | /* UnconstrainedMapGenerator.kt:102 */
|
1062 1288 | type Error = crate::model::map_of_range_short_internal::ConstraintViolation;
|
1289 + | /* UnconstrainedMapGenerator.kt:104 */
|
1063 1290 | fn try_from(value: MapOfRangeShortUnconstrained) -> std::result::Result<Self, Self::Error> {
|
1291 + | /* UnconstrainedMapGenerator.kt:186 */
|
1064 1292 | let res: ::std::result::Result<
|
1065 1293 | ::std::collections::HashMap<::std::string::String, crate::model::RangeShort>,
|
1066 1294 | Self::Error,
|
1067 1295 | > = value
|
1068 1296 | .0
|
1069 1297 | .into_iter()
|
1070 1298 | .map(|(k, v)| match crate::model::RangeShort::try_from(v) {
|
1071 1299 | Ok(v) => Ok((k, v)),
|
1072 1300 | Err(inner_constraint_violation) => {
|
1073 1301 | Err(Self::Error::Value(k, inner_constraint_violation))
|
1074 1302 | }
|
1075 1303 | })
|
1076 1304 | .collect();
|
1077 1305 | let hm = res?;
|
1306 + | /* UnconstrainedMapGenerator.kt:247 */
|
1078 1307 | Ok(Self(hm))
|
1308 + | /* UnconstrainedMapGenerator.kt:104 */
|
1079 1309 | }
|
1310 + | /* UnconstrainedMapGenerator.kt:101 */
|
1080 1311 | }
|
1312 + |
|
1313 + | /* RustCrateInlineModuleComposingWriter.kt:299 */
|
1081 1314 | }
|
1082 1315 | pub(crate) mod set_of_range_short_unconstrained {
|
1083 1316 |
|
1317 + | /* UnconstrainedCollectionGenerator.kt:77 */
|
1084 1318 | #[derive(Debug, Clone)]
|
1085 1319 | pub(crate) struct SetOfRangeShortUnconstrained(pub(crate) std::vec::Vec<i16>);
|
1086 1320 |
|
1087 1321 | impl From<SetOfRangeShortUnconstrained>
|
1088 1322 | for crate::constrained::MaybeConstrained<crate::model::SetOfRangeShort>
|
1089 1323 | {
|
1090 1324 | fn from(value: SetOfRangeShortUnconstrained) -> Self {
|
1091 1325 | Self::Unconstrained(value)
|
1092 1326 | }
|
1093 1327 | }
|
1328 + | /* UnconstrainedCollectionGenerator.kt:97 */
|
1094 1329 | impl std::convert::TryFrom<SetOfRangeShortUnconstrained> for crate::model::SetOfRangeShort {
|
1330 + | /* UnconstrainedCollectionGenerator.kt:98 */
|
1095 1331 | type Error = crate::model::set_of_range_short_internal::ConstraintViolation;
|
1332 + | /* UnconstrainedCollectionGenerator.kt:100 */
|
1096 1333 | fn try_from(value: SetOfRangeShortUnconstrained) -> std::result::Result<Self, Self::Error> {
|
1334 + | /* UnconstrainedCollectionGenerator.kt:127 */
|
1097 1335 | let res: ::std::result::Result<
|
1098 1336 | ::std::vec::Vec<crate::model::RangeShort>,
|
1099 1337 | (
|
1100 1338 | usize,
|
1101 1339 | crate::model::range_short_internal::ConstraintViolation,
|
1102 1340 | ),
|
1103 1341 | > = value
|
1104 1342 | .0
|
1105 1343 | .into_iter()
|
1106 1344 | .enumerate()
|
1107 1345 | .map(|(idx, inner)| {
|
1108 1346 | inner
|
1109 1347 | .try_into()
|
1110 1348 | .map_err(|inner_violation| (idx, inner_violation))
|
1111 1349 | })
|
1112 1350 | .collect();
|
1113 1351 | let inner =
|
1114 1352 | res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
|
1353 + | /* UnconstrainedCollectionGenerator.kt:189 */
|
1115 1354 | Self::try_from(inner)
|
1355 + | /* UnconstrainedCollectionGenerator.kt:100 */
|
1116 1356 | }
|
1357 + | /* UnconstrainedCollectionGenerator.kt:97 */
|
1117 1358 | }
|
1359 + |
|
1360 + | /* RustCrateInlineModuleComposingWriter.kt:299 */
|
1118 1361 | }
|
1119 1362 | pub(crate) mod list_of_range_short_unconstrained {
|
1120 1363 |
|
1364 + | /* UnconstrainedCollectionGenerator.kt:77 */
|
1121 1365 | #[derive(Debug, Clone)]
|
1122 1366 | pub(crate) struct ListOfRangeShortUnconstrained(pub(crate) std::vec::Vec<i16>);
|
1123 1367 |
|
1124 1368 | impl From<ListOfRangeShortUnconstrained>
|
1125 1369 | for crate::constrained::MaybeConstrained<
|
1126 1370 | crate::constrained::list_of_range_short_constrained::ListOfRangeShortConstrained,
|
1127 1371 | >
|
1128 1372 | {
|
1129 1373 | fn from(value: ListOfRangeShortUnconstrained) -> Self {
|
1130 1374 | Self::Unconstrained(value)
|
1131 1375 | }
|
1132 1376 | }
|
1377 + | /* UnconstrainedCollectionGenerator.kt:97 */
|
1133 1378 | impl std::convert::TryFrom<ListOfRangeShortUnconstrained>
|
1134 1379 | for crate::constrained::list_of_range_short_constrained::ListOfRangeShortConstrained
|
1135 1380 | {
|
1381 + | /* UnconstrainedCollectionGenerator.kt:98 */
|
1136 1382 | type Error = crate::model::list_of_range_short_internal::ConstraintViolation;
|
1383 + | /* UnconstrainedCollectionGenerator.kt:100 */
|
1137 1384 | fn try_from(
|
1138 1385 | value: ListOfRangeShortUnconstrained,
|
1139 1386 | ) -> std::result::Result<Self, Self::Error> {
|
1387 + | /* UnconstrainedCollectionGenerator.kt:127 */
|
1140 1388 | let res: ::std::result::Result<
|
1141 1389 | ::std::vec::Vec<crate::model::RangeShort>,
|
1142 1390 | (
|
1143 1391 | usize,
|
1144 1392 | crate::model::range_short_internal::ConstraintViolation,
|
1145 1393 | ),
|
1146 1394 | > = value
|
1147 1395 | .0
|
1148 1396 | .into_iter()
|
1149 1397 | .enumerate()
|
1150 1398 | .map(|(idx, inner)| {
|
1151 1399 | inner
|
1152 1400 | .try_into()
|
1153 1401 | .map_err(|inner_violation| (idx, inner_violation))
|
1154 1402 | })
|
1155 1403 | .collect();
|
1156 1404 | let inner =
|
1157 1405 | res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
|
1406 + | /* UnconstrainedCollectionGenerator.kt:191 */
|
1158 1407 | Ok(Self(inner))
|
1408 + | /* UnconstrainedCollectionGenerator.kt:100 */
|
1159 1409 | }
|
1410 + | /* UnconstrainedCollectionGenerator.kt:97 */
|
1160 1411 | }
|
1412 + |
|
1413 + | /* RustCrateInlineModuleComposingWriter.kt:299 */
|
1161 1414 | }
|
1162 1415 | pub(crate) mod map_of_range_integer_unconstrained {
|
1163 1416 |
|
1417 + | /* UnconstrainedMapGenerator.kt:79 */
|
1164 1418 | #[derive(Debug, Clone)]
|
1165 1419 | pub(crate) struct MapOfRangeIntegerUnconstrained(
|
1166 1420 | pub(crate) std::collections::HashMap<::std::string::String, i32>,
|
1167 1421 | );
|
1168 1422 |
|
1169 1423 | impl From<MapOfRangeIntegerUnconstrained>
|
1170 1424 | for crate::constrained::MaybeConstrained<
|
1171 1425 | crate::constrained::map_of_range_integer_constrained::MapOfRangeIntegerConstrained,
|
1172 1426 | >
|
1173 1427 | {
|
1174 1428 | fn from(value: MapOfRangeIntegerUnconstrained) -> Self {
|
1175 1429 | Self::Unconstrained(value)
|
1176 1430 | }
|
1177 1431 | }
|
1432 + | /* UnconstrainedMapGenerator.kt:101 */
|
1178 1433 | impl std::convert::TryFrom<MapOfRangeIntegerUnconstrained>
|
1179 1434 | for crate::constrained::map_of_range_integer_constrained::MapOfRangeIntegerConstrained
|
1180 1435 | {
|
1436 + | /* UnconstrainedMapGenerator.kt:102 */
|
1181 1437 | type Error = crate::model::map_of_range_integer_internal::ConstraintViolation;
|
1438 + | /* UnconstrainedMapGenerator.kt:104 */
|
1182 1439 | fn try_from(
|
1183 1440 | value: MapOfRangeIntegerUnconstrained,
|
1184 1441 | ) -> std::result::Result<Self, Self::Error> {
|
1442 + | /* UnconstrainedMapGenerator.kt:186 */
|
1185 1443 | let res: ::std::result::Result<
|
1186 1444 | ::std::collections::HashMap<::std::string::String, crate::model::RangeInteger>,
|
1187 1445 | Self::Error,
|
1188 1446 | > = value
|
1189 1447 | .0
|
1190 1448 | .into_iter()
|
1191 1449 | .map(|(k, v)| match crate::model::RangeInteger::try_from(v) {
|
1192 1450 | Ok(v) => Ok((k, v)),
|
1193 1451 | Err(inner_constraint_violation) => {
|
1194 1452 | Err(Self::Error::Value(k, inner_constraint_violation))
|
1195 1453 | }
|
1196 1454 | })
|
1197 1455 | .collect();
|
1198 1456 | let hm = res?;
|
1457 + | /* UnconstrainedMapGenerator.kt:247 */
|
1199 1458 | Ok(Self(hm))
|
1459 + | /* UnconstrainedMapGenerator.kt:104 */
|
1200 1460 | }
|
1461 + | /* UnconstrainedMapGenerator.kt:101 */
|
1201 1462 | }
|
1463 + |
|
1464 + | /* RustCrateInlineModuleComposingWriter.kt:299 */
|
1202 1465 | }
|
1203 1466 | pub(crate) mod set_of_range_integer_unconstrained {
|
1204 1467 |
|
1468 + | /* UnconstrainedCollectionGenerator.kt:77 */
|
1205 1469 | #[derive(Debug, Clone)]
|
1206 1470 | pub(crate) struct SetOfRangeIntegerUnconstrained(pub(crate) std::vec::Vec<i32>);
|
1207 1471 |
|
1208 1472 | impl From<SetOfRangeIntegerUnconstrained>
|
1209 1473 | for crate::constrained::MaybeConstrained<crate::model::SetOfRangeInteger>
|
1210 1474 | {
|
1211 1475 | fn from(value: SetOfRangeIntegerUnconstrained) -> Self {
|
1212 1476 | Self::Unconstrained(value)
|
1213 1477 | }
|
1214 1478 | }
|
1479 + | /* UnconstrainedCollectionGenerator.kt:97 */
|
1215 1480 | impl std::convert::TryFrom<SetOfRangeIntegerUnconstrained> for crate::model::SetOfRangeInteger {
|
1481 + | /* UnconstrainedCollectionGenerator.kt:98 */
|
1216 1482 | type Error = crate::model::set_of_range_integer_internal::ConstraintViolation;
|
1483 + | /* UnconstrainedCollectionGenerator.kt:100 */
|
1217 1484 | fn try_from(
|
1218 1485 | value: SetOfRangeIntegerUnconstrained,
|
1219 1486 | ) -> std::result::Result<Self, Self::Error> {
|
1487 + | /* UnconstrainedCollectionGenerator.kt:127 */
|
1220 1488 | let res: ::std::result::Result<
|
1221 1489 | ::std::vec::Vec<crate::model::RangeInteger>,
|
1222 1490 | (
|
1223 1491 | usize,
|
1224 1492 | crate::model::range_integer_internal::ConstraintViolation,
|
1225 1493 | ),
|
1226 1494 | > = value
|
1227 1495 | .0
|
1228 1496 | .into_iter()
|
1229 1497 | .enumerate()
|
1230 1498 | .map(|(idx, inner)| {
|
1231 1499 | inner
|
1232 1500 | .try_into()
|
1233 1501 | .map_err(|inner_violation| (idx, inner_violation))
|
1234 1502 | })
|
1235 1503 | .collect();
|
1236 1504 | let inner =
|
1237 1505 | res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
|
1506 + | /* UnconstrainedCollectionGenerator.kt:189 */
|
1238 1507 | Self::try_from(inner)
|
1508 + | /* UnconstrainedCollectionGenerator.kt:100 */
|
1239 1509 | }
|
1510 + | /* UnconstrainedCollectionGenerator.kt:97 */
|
1240 1511 | }
|
1512 + |
|
1513 + | /* RustCrateInlineModuleComposingWriter.kt:299 */
|
1241 1514 | }
|
1242 1515 | pub(crate) mod list_of_range_integer_unconstrained {
|
1243 1516 |
|
1517 + | /* UnconstrainedCollectionGenerator.kt:77 */
|
1244 1518 | #[derive(Debug, Clone)]
|
1245 1519 | pub(crate) struct ListOfRangeIntegerUnconstrained(pub(crate) std::vec::Vec<i32>);
|
1246 1520 |
|
1247 1521 | impl From<ListOfRangeIntegerUnconstrained>
|
1248 1522 | for crate::constrained::MaybeConstrained<
|
1249 1523 | crate::constrained::list_of_range_integer_constrained::ListOfRangeIntegerConstrained,
|
1250 1524 | >
|
1251 1525 | {
|
1252 1526 | fn from(value: ListOfRangeIntegerUnconstrained) -> Self {
|
1253 1527 | Self::Unconstrained(value)
|
1254 1528 | }
|
1255 1529 | }
|
1530 + | /* UnconstrainedCollectionGenerator.kt:97 */
|
1256 1531 | impl std::convert::TryFrom<ListOfRangeIntegerUnconstrained>
|
1257 1532 | for crate::constrained::list_of_range_integer_constrained::ListOfRangeIntegerConstrained
|
1258 1533 | {
|
1534 + | /* UnconstrainedCollectionGenerator.kt:98 */
|
1259 1535 | type Error = crate::model::list_of_range_integer_internal::ConstraintViolation;
|
1536 + | /* UnconstrainedCollectionGenerator.kt:100 */
|
1260 1537 | fn try_from(
|
1261 1538 | value: ListOfRangeIntegerUnconstrained,
|
1262 1539 | ) -> std::result::Result<Self, Self::Error> {
|
1540 + | /* UnconstrainedCollectionGenerator.kt:127 */
|
1263 1541 | let res: ::std::result::Result<
|
1264 1542 | ::std::vec::Vec<crate::model::RangeInteger>,
|
1265 1543 | (
|
1266 1544 | usize,
|
1267 1545 | crate::model::range_integer_internal::ConstraintViolation,
|
1268 1546 | ),
|
1269 1547 | > = value
|
1270 1548 | .0
|
1271 1549 | .into_iter()
|
1272 1550 | .enumerate()
|
1273 1551 | .map(|(idx, inner)| {
|
1274 1552 | inner
|
1275 1553 | .try_into()
|
1276 1554 | .map_err(|inner_violation| (idx, inner_violation))
|
1277 1555 | })
|
1278 1556 | .collect();
|
1279 1557 | let inner =
|
1280 1558 | res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
|
1559 + | /* UnconstrainedCollectionGenerator.kt:191 */
|
1281 1560 | Ok(Self(inner))
|
1561 + | /* UnconstrainedCollectionGenerator.kt:100 */
|
1282 1562 | }
|
1563 + | /* UnconstrainedCollectionGenerator.kt:97 */
|
1283 1564 | }
|
1565 + |
|
1566 + | /* RustCrateInlineModuleComposingWriter.kt:299 */
|
1284 1567 | }
|
1285 1568 | pub(crate) mod map_of_length_blob_unconstrained {
|
1286 1569 |
|
1570 + | /* UnconstrainedMapGenerator.kt:79 */
|
1287 1571 | #[derive(Debug, Clone)]
|
1288 1572 | pub(crate) struct MapOfLengthBlobUnconstrained(
|
1289 1573 | pub(crate) std::collections::HashMap<
|
1290 1574 | ::std::string::String,
|
1291 1575 | ::aws_smithy_http_server_python::types::Blob,
|
1292 1576 | >,
|
1293 1577 | );
|
1294 1578 |
|
1295 1579 | impl From<MapOfLengthBlobUnconstrained>
|
1296 1580 | for crate::constrained::MaybeConstrained<
|
1297 1581 | crate::constrained::map_of_length_blob_constrained::MapOfLengthBlobConstrained,
|
1298 1582 | >
|
1299 1583 | {
|
1300 1584 | fn from(value: MapOfLengthBlobUnconstrained) -> Self {
|
1301 1585 | Self::Unconstrained(value)
|
1302 1586 | }
|
1303 1587 | }
|
1588 + | /* UnconstrainedMapGenerator.kt:101 */
|
1304 1589 | impl std::convert::TryFrom<MapOfLengthBlobUnconstrained>
|
1305 1590 | for crate::constrained::map_of_length_blob_constrained::MapOfLengthBlobConstrained
|
1306 1591 | {
|
1592 + | /* UnconstrainedMapGenerator.kt:102 */
|
1307 1593 | type Error = crate::model::map_of_length_blob_internal::ConstraintViolation;
|
1594 + | /* UnconstrainedMapGenerator.kt:104 */
|
1308 1595 | fn try_from(value: MapOfLengthBlobUnconstrained) -> std::result::Result<Self, Self::Error> {
|
1596 + | /* UnconstrainedMapGenerator.kt:186 */
|
1309 1597 | let res: ::std::result::Result<
|
1310 1598 | ::std::collections::HashMap<::std::string::String, crate::model::LengthBlob>,
|
1311 1599 | Self::Error,
|
1312 1600 | > = value
|
1313 1601 | .0
|
1314 1602 | .into_iter()
|
1315 1603 | .map(|(k, v)| match crate::model::LengthBlob::try_from(v) {
|
1316 1604 | Ok(v) => Ok((k, v)),
|
1317 1605 | Err(inner_constraint_violation) => {
|
1318 1606 | Err(Self::Error::Value(k, inner_constraint_violation))
|
1319 1607 | }
|
1320 1608 | })
|
1321 1609 | .collect();
|
1322 1610 | let hm = res?;
|
1611 + | /* UnconstrainedMapGenerator.kt:247 */
|
1323 1612 | Ok(Self(hm))
|
1613 + | /* UnconstrainedMapGenerator.kt:104 */
|
1324 1614 | }
|
1615 + | /* UnconstrainedMapGenerator.kt:101 */
|
1325 1616 | }
|
1617 + |
|
1618 + | /* RustCrateInlineModuleComposingWriter.kt:299 */
|
1326 1619 | }
|
1327 1620 | pub(crate) mod list_of_length_blob_unconstrained {
|
1328 1621 |
|
1622 + | /* UnconstrainedCollectionGenerator.kt:77 */
|
1329 1623 | #[derive(Debug, Clone)]
|
1330 1624 | pub(crate) struct ListOfLengthBlobUnconstrained(
|
1331 1625 | pub(crate) std::vec::Vec<::aws_smithy_http_server_python::types::Blob>,
|
1332 1626 | );
|
1333 1627 |
|
1334 1628 | impl From<ListOfLengthBlobUnconstrained>
|
1335 1629 | for crate::constrained::MaybeConstrained<
|
1336 1630 | crate::constrained::list_of_length_blob_constrained::ListOfLengthBlobConstrained,
|
1337 1631 | >
|
1338 1632 | {
|
1339 1633 | fn from(value: ListOfLengthBlobUnconstrained) -> Self {
|
1340 1634 | Self::Unconstrained(value)
|
1341 1635 | }
|
1342 1636 | }
|
1637 + | /* UnconstrainedCollectionGenerator.kt:97 */
|
1343 1638 | impl std::convert::TryFrom<ListOfLengthBlobUnconstrained>
|
1344 1639 | for crate::constrained::list_of_length_blob_constrained::ListOfLengthBlobConstrained
|
1345 1640 | {
|
1641 + | /* UnconstrainedCollectionGenerator.kt:98 */
|
1346 1642 | type Error = crate::model::list_of_length_blob_internal::ConstraintViolation;
|
1643 + | /* UnconstrainedCollectionGenerator.kt:100 */
|
1347 1644 | fn try_from(
|
1348 1645 | value: ListOfLengthBlobUnconstrained,
|
1349 1646 | ) -> std::result::Result<Self, Self::Error> {
|
1647 + | /* UnconstrainedCollectionGenerator.kt:127 */
|
1350 1648 | let res: ::std::result::Result<
|
1351 1649 | ::std::vec::Vec<crate::model::LengthBlob>,
|
1352 1650 | (
|
1353 1651 | usize,
|
1354 1652 | crate::model::length_blob_internal::ConstraintViolation,
|
1355 1653 | ),
|
1356 1654 | > = value
|
1357 1655 | .0
|
1358 1656 | .into_iter()
|
1359 1657 | .enumerate()
|
1360 1658 | .map(|(idx, inner)| {
|
1361 1659 | inner
|
1362 1660 | .try_into()
|
1363 1661 | .map_err(|inner_violation| (idx, inner_violation))
|
1364 1662 | })
|
1365 1663 | .collect();
|
1366 1664 | let inner =
|
1367 1665 | res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
|
1666 + | /* UnconstrainedCollectionGenerator.kt:191 */
|
1368 1667 | Ok(Self(inner))
|
1668 + | /* UnconstrainedCollectionGenerator.kt:100 */
|
1369 1669 | }
|
1670 + | /* UnconstrainedCollectionGenerator.kt:97 */
|
1370 1671 | }
|
1672 + |
|
1673 + | /* RustCrateInlineModuleComposingWriter.kt:299 */
|
1371 1674 | }
|
1372 1675 | pub(crate) mod constrained_union_unconstrained {
|
1373 1676 |
|
1677 + | /* UnconstrainedUnionGenerator.kt:82 */
|
1374 1678 | #[allow(clippy::enum_variant_names)]
|
1375 1679 | #[derive(Debug, Clone)]
|
1376 1680 | pub(crate) enum ConstrainedUnionUnconstrained {
|
1681 + | /* UnconstrainedUnionGenerator.kt:95 */
|
1377 1682 | ConBList(crate::unconstrained::con_b_list_unconstrained::ConBListUnconstrained),
|
1683 + | /* UnconstrainedUnionGenerator.kt:95 */
|
1378 1684 | ConBMap(crate::unconstrained::con_b_map_unconstrained::ConBMapUnconstrained),
|
1685 + | /* UnconstrainedUnionGenerator.kt:95 */
|
1379 1686 | ConBSet(crate::unconstrained::con_b_set_unconstrained::ConBSetUnconstrained),
|
1687 + | /* UnconstrainedUnionGenerator.kt:95 */
|
1380 1688 | ConstrainedStructure(crate::model::con_b_internal::Builder),
|
1381 - | EnumString(::std::string::String),
|
1689 + | /* UnconstrainedUnionGenerator.kt:95 */ EnumString(::std::string::String),
|
1690 + | /* UnconstrainedUnionGenerator.kt:95 */
|
1382 1691 | LengthString(::std::string::String),
|
1692 + | /* UnconstrainedUnionGenerator.kt:82 */
|
1383 1693 | }
|
1694 + | /* UnconstrainedUnionGenerator.kt:103 */
|
1384 1695 | impl ::std::convert::TryFrom<ConstrainedUnionUnconstrained> for crate::model::ConstrainedUnion {
|
1385 1696 | type Error = crate::model::constrained_union_internal::ConstraintViolation;
|
1386 1697 |
|
1387 1698 | fn try_from(
|
1388 1699 | value: ConstrainedUnionUnconstrained,
|
1389 1700 | ) -> ::std::result::Result<Self, Self::Error> {
|
1390 1701 | Ok(
|
1391 1702 | match value {
|
1392 1703 | crate::unconstrained::constrained_union_unconstrained::ConstrainedUnionUnconstrained::ConBList(unconstrained) => Self::ConBList(
|
1393 1704 | {
|
1394 1705 | let constrained: crate::constrained::con_b_list_constrained::ConBListConstrained = unconstrained
|
1395 1706 | .try_into()
|
1396 1707 | .map_err(Self::Error::ConBList)?;
|
1397 1708 | constrained.into()
|
1398 1709 | }
|
1399 1710 | ),
|
1400 1711 | crate::unconstrained::constrained_union_unconstrained::ConstrainedUnionUnconstrained::ConBMap(unconstrained) => Self::ConBMap(
|
1401 1712 | {
|
1402 1713 | let constrained: crate::model::ConBMap = unconstrained
|
1403 1714 | .try_into()
|
1404 1715 | .map_err(Self::Error::ConBMap)?;
|
1405 1716 | constrained.into()
|
1406 1717 | }
|
1407 1718 | ),
|
1408 1719 | crate::unconstrained::constrained_union_unconstrained::ConstrainedUnionUnconstrained::ConBSet(unconstrained) => Self::ConBSet(
|
1409 1720 | {
|
1410 1721 | let constrained: crate::model::ConBSet = unconstrained
|
1411 1722 | .try_into()
|
1412 1723 | .map_err(Self::Error::ConBSet)?;
|
1413 1724 | constrained.into()
|
1414 1725 | }
|
1415 1726 | ),
|
1416 1727 | crate::unconstrained::constrained_union_unconstrained::ConstrainedUnionUnconstrained::ConstrainedStructure(unconstrained) => Self::ConstrainedStructure(
|
1417 1728 | unconstrained
|
1418 1729 | .try_into()
|
1419 1730 |
|
1420 1731 |
|
1421 1732 | .map_err(Self::Error::ConstrainedStructure)?
|
1422 1733 | ),
|
1423 1734 | crate::unconstrained::constrained_union_unconstrained::ConstrainedUnionUnconstrained::EnumString(unconstrained) => Self::EnumString(
|
1424 1735 | unconstrained
|
1425 1736 | .try_into()
|
1426 1737 |
|
1427 1738 |
|
1428 1739 | .map_err(Self::Error::EnumString)?
|
1429 1740 | ),
|
1430 1741 | crate::unconstrained::constrained_union_unconstrained::ConstrainedUnionUnconstrained::LengthString(unconstrained) => Self::LengthString(
|
1431 1742 | {
|
1432 1743 | let constrained: crate::model::LengthString = unconstrained
|
1433 1744 | .try_into()
|
1434 1745 | .map_err(Self::Error::LengthString)?;
|
1435 1746 | constrained.into()
|
1436 1747 | }
|
1437 1748 | ),
|
1438 1749 | }
|
1439 1750 | )
|
1440 1751 | }
|
1441 1752 | }
|
1753 + |
|
1754 + | /* RustCrateInlineModuleComposingWriter.kt:299 */
|
1442 1755 | }
|
1443 1756 | pub(crate) mod con_b_set_unconstrained {
|
1444 1757 |
|
1758 + | /* UnconstrainedCollectionGenerator.kt:77 */
|
1445 1759 | #[derive(Debug, Clone)]
|
1446 1760 | pub(crate) struct ConBSetUnconstrained(
|
1447 1761 | pub(crate) std::vec::Vec<
|
1448 1762 | crate::unconstrained::con_b_set_inner_unconstrained::ConBSetInnerUnconstrained,
|
1449 1763 | >,
|
1450 1764 | );
|
1451 1765 |
|
1452 1766 | impl From<ConBSetUnconstrained> for crate::constrained::MaybeConstrained<crate::model::ConBSet> {
|
1453 1767 | fn from(value: ConBSetUnconstrained) -> Self {
|
1454 1768 | Self::Unconstrained(value)
|
1455 1769 | }
|
1456 1770 | }
|
1771 + | /* UnconstrainedCollectionGenerator.kt:97 */
|
1457 1772 | impl std::convert::TryFrom<ConBSetUnconstrained> for crate::model::ConBSet {
|
1773 + | /* UnconstrainedCollectionGenerator.kt:98 */
|
1458 1774 | type Error = crate::model::con_b_set_internal::ConstraintViolation;
|
1775 + | /* UnconstrainedCollectionGenerator.kt:100 */
|
1459 1776 | fn try_from(value: ConBSetUnconstrained) -> std::result::Result<Self, Self::Error> {
|
1777 + | /* UnconstrainedCollectionGenerator.kt:127 */
|
1460 1778 | let res: ::std::result::Result<
|
1461 1779 | ::std::vec::Vec<crate::model::ConBSetInner>,
|
1462 1780 | (
|
1463 1781 | usize,
|
1464 1782 | crate::model::con_b_set_inner_internal::ConstraintViolation,
|
1465 1783 | ),
|
1466 1784 | > = value
|
1467 1785 | .0
|
1468 1786 | .into_iter()
|
1469 1787 | .enumerate()
|
1470 1788 | .map(|(idx, inner)| {
|
1471 1789 | inner
|
1472 1790 | .try_into()
|
1473 1791 | .map_err(|inner_violation| (idx, inner_violation))
|
1474 1792 | })
|
1475 1793 | .collect();
|
1476 1794 | let inner =
|
1477 1795 | res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
|
1796 + | /* UnconstrainedCollectionGenerator.kt:189 */
|
1478 1797 | Self::try_from(inner)
|
1798 + | /* UnconstrainedCollectionGenerator.kt:100 */
|
1479 1799 | }
|
1800 + | /* UnconstrainedCollectionGenerator.kt:97 */
|
1480 1801 | }
|
1802 + |
|
1803 + | /* RustCrateInlineModuleComposingWriter.kt:299 */
|
1481 1804 | }
|
1482 1805 | pub(crate) mod con_b_set_inner_unconstrained {
|
1483 1806 |
|
1807 + | /* UnconstrainedCollectionGenerator.kt:77 */
|
1484 1808 | #[derive(Debug, Clone)]
|
1485 1809 | pub(crate) struct ConBSetInnerUnconstrained(pub(crate) std::vec::Vec<::std::string::String>);
|
1486 1810 |
|
1487 1811 | impl From<ConBSetInnerUnconstrained>
|
1488 1812 | for crate::constrained::MaybeConstrained<crate::model::ConBSetInner>
|
1489 1813 | {
|
1490 1814 | fn from(value: ConBSetInnerUnconstrained) -> Self {
|
1491 1815 | Self::Unconstrained(value)
|
1492 1816 | }
|
1493 1817 | }
|
1818 + | /* UnconstrainedCollectionGenerator.kt:97 */
|
1494 1819 | impl std::convert::TryFrom<ConBSetInnerUnconstrained> for crate::model::ConBSetInner {
|
1820 + | /* UnconstrainedCollectionGenerator.kt:98 */
|
1495 1821 | type Error = crate::model::con_b_set_inner_internal::ConstraintViolation;
|
1822 + | /* UnconstrainedCollectionGenerator.kt:100 */
|
1496 1823 | fn try_from(value: ConBSetInnerUnconstrained) -> std::result::Result<Self, Self::Error> {
|
1824 + | /* UnconstrainedCollectionGenerator.kt:185 */
|
1497 1825 | let inner = value.0;
|
1826 + | /* UnconstrainedCollectionGenerator.kt:189 */
|
1498 1827 | Self::try_from(inner)
|
1828 + | /* UnconstrainedCollectionGenerator.kt:100 */
|
1499 1829 | }
|
1830 + | /* UnconstrainedCollectionGenerator.kt:97 */
|
1500 1831 | }
|
1832 + |
|
1833 + | /* RustCrateInlineModuleComposingWriter.kt:299 */
|
1501 1834 | }
|
1502 1835 | pub(crate) mod con_b_list_unconstrained {
|
1503 1836 |
|
1837 + | /* UnconstrainedCollectionGenerator.kt:77 */
|
1504 1838 | #[derive(Debug, Clone)]
|
1505 1839 | pub(crate) struct ConBListUnconstrained(
|
1506 1840 | pub(crate) std::vec::Vec<
|
1507 1841 | crate::unconstrained::con_b_list_inner_unconstrained::ConBListInnerUnconstrained,
|
1508 1842 | >,
|
1509 1843 | );
|
1510 1844 |
|
1511 1845 | impl From<ConBListUnconstrained>
|
1512 1846 | for crate::constrained::MaybeConstrained<
|
1513 1847 | crate::constrained::con_b_list_constrained::ConBListConstrained,
|
1514 1848 | >
|
1515 1849 | {
|
1516 1850 | fn from(value: ConBListUnconstrained) -> Self {
|
1517 1851 | Self::Unconstrained(value)
|
1518 1852 | }
|
1519 1853 | }
|
1854 + | /* UnconstrainedCollectionGenerator.kt:97 */
|
1520 1855 | impl std::convert::TryFrom<ConBListUnconstrained>
|
1521 1856 | for crate::constrained::con_b_list_constrained::ConBListConstrained
|
1522 1857 | {
|
1858 + | /* UnconstrainedCollectionGenerator.kt:98 */
|
1523 1859 | type Error = crate::model::con_b_list_internal::ConstraintViolation;
|
1860 + | /* UnconstrainedCollectionGenerator.kt:100 */
|
1524 1861 | fn try_from(value: ConBListUnconstrained) -> std::result::Result<Self, Self::Error> {
|
1862 + | /* UnconstrainedCollectionGenerator.kt:127 */
|
1525 1863 | let res: ::std::result::Result<
|
1526 1864 | ::std::vec::Vec<
|
1527 1865 | crate::constrained::con_b_list_inner_constrained::ConBListInnerConstrained,
|
1528 1866 | >,
|
1529 1867 | (
|
1530 1868 | usize,
|
1531 1869 | crate::model::con_b_list_inner_internal::ConstraintViolation,
|
1532 1870 | ),
|
1533 1871 | > = value
|
1534 1872 | .0
|
1535 1873 | .into_iter()
|
1536 1874 | .enumerate()
|
1537 1875 | .map(|(idx, inner)| {
|
1538 1876 | inner
|
1539 1877 | .try_into()
|
1540 1878 | .map_err(|inner_violation| (idx, inner_violation))
|
1541 1879 | })
|
1542 1880 | .collect();
|
1543 1881 | let inner =
|
1544 1882 | res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
|
1883 + | /* UnconstrainedCollectionGenerator.kt:191 */
|
1545 1884 | Ok(Self(inner))
|
1885 + | /* UnconstrainedCollectionGenerator.kt:100 */
|
1546 1886 | }
|
1887 + | /* UnconstrainedCollectionGenerator.kt:97 */
|
1547 1888 | }
|
1889 + |
|
1890 + | /* RustCrateInlineModuleComposingWriter.kt:299 */
|
1548 1891 | }
|
1549 1892 | pub(crate) mod con_b_list_inner_unconstrained {
|
1550 1893 |
|
1894 + | /* UnconstrainedCollectionGenerator.kt:77 */
|
1551 1895 | #[derive(Debug, Clone)]
|
1552 1896 | pub(crate) struct ConBListInnerUnconstrained(
|
1553 1897 | pub(crate) std::vec::Vec<crate::model::con_b_internal::Builder>,
|
1554 1898 | );
|
1555 1899 |
|
1556 1900 | impl From<ConBListInnerUnconstrained>
|
1557 1901 | for crate::constrained::MaybeConstrained<
|
1558 1902 | crate::constrained::con_b_list_inner_constrained::ConBListInnerConstrained,
|
1559 1903 | >
|
1560 1904 | {
|
1561 1905 | fn from(value: ConBListInnerUnconstrained) -> Self {
|
1562 1906 | Self::Unconstrained(value)
|
1563 1907 | }
|
1564 1908 | }
|
1909 + | /* UnconstrainedCollectionGenerator.kt:97 */
|
1565 1910 | impl std::convert::TryFrom<ConBListInnerUnconstrained>
|
1566 1911 | for crate::constrained::con_b_list_inner_constrained::ConBListInnerConstrained
|
1567 1912 | {
|
1913 + | /* UnconstrainedCollectionGenerator.kt:98 */
|
1568 1914 | type Error = crate::model::con_b_list_inner_internal::ConstraintViolation;
|
1915 + | /* UnconstrainedCollectionGenerator.kt:100 */
|
1569 1916 | fn try_from(value: ConBListInnerUnconstrained) -> std::result::Result<Self, Self::Error> {
|
1917 + | /* UnconstrainedCollectionGenerator.kt:127 */
|
1570 1918 | let res: ::std::result::Result<
|
1571 1919 | ::std::vec::Vec<crate::model::ConB>,
|
1572 1920 | (usize, crate::model::con_b_internal::ConstraintViolation),
|
1573 1921 | > = value
|
1574 1922 | .0
|
1575 1923 | .into_iter()
|
1576 1924 | .enumerate()
|
1577 1925 | .map(|(idx, inner)| {
|
1578 1926 | inner
|
1579 1927 | .try_into()
|
1580 1928 | .map_err(|inner_violation| (idx, inner_violation))
|
1581 1929 | })
|
1582 1930 | .collect();
|
1583 1931 | let inner =
|
1584 1932 | res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
|
1933 + | /* UnconstrainedCollectionGenerator.kt:191 */
|
1585 1934 | Ok(Self(inner))
|
1935 + | /* UnconstrainedCollectionGenerator.kt:100 */
|
1586 1936 | }
|
1937 + | /* UnconstrainedCollectionGenerator.kt:97 */
|
1587 1938 | }
|
1939 + |
|
1940 + | /* RustCrateInlineModuleComposingWriter.kt:299 */
|
1588 1941 | }
|
1589 1942 | pub(crate) mod sparse_length_list_unconstrained {
|
1590 1943 |
|
1944 + | /* UnconstrainedCollectionGenerator.kt:77 */
|
1591 1945 | #[derive(Debug, Clone)]
|
1592 1946 | pub(crate) struct SparseLengthListUnconstrained(
|
1593 1947 | pub(crate) std::vec::Vec<::std::option::Option<::std::string::String>>,
|
1594 1948 | );
|
1595 1949 |
|
1596 1950 | impl From<SparseLengthListUnconstrained>
|
1597 1951 | for crate::constrained::MaybeConstrained<crate::model::SparseLengthList>
|
1598 1952 | {
|
1599 1953 | fn from(value: SparseLengthListUnconstrained) -> Self {
|
1600 1954 | Self::Unconstrained(value)
|
1601 1955 | }
|
1602 1956 | }
|
1957 + | /* UnconstrainedCollectionGenerator.kt:97 */
|
1603 1958 | impl std::convert::TryFrom<SparseLengthListUnconstrained> for crate::model::SparseLengthList {
|
1959 + | /* UnconstrainedCollectionGenerator.kt:98 */
|
1604 1960 | type Error = crate::model::sparse_length_list_internal::ConstraintViolation;
|
1961 + | /* UnconstrainedCollectionGenerator.kt:100 */
|
1605 1962 | fn try_from(
|
1606 1963 | value: SparseLengthListUnconstrained,
|
1607 1964 | ) -> std::result::Result<Self, Self::Error> {
|
1965 + | /* UnconstrainedCollectionGenerator.kt:185 */
|
1608 1966 | let inner = value.0;
|
1967 + | /* UnconstrainedCollectionGenerator.kt:189 */
|
1609 1968 | Self::try_from(inner)
|
1969 + | /* UnconstrainedCollectionGenerator.kt:100 */
|
1610 1970 | }
|
1971 + | /* UnconstrainedCollectionGenerator.kt:97 */
|
1611 1972 | }
|
1973 + |
|
1974 + | /* RustCrateInlineModuleComposingWriter.kt:299 */
|
1612 1975 | }
|
1613 1976 | pub(crate) mod sparse_length_map_unconstrained {
|
1614 1977 |
|
1978 + | /* UnconstrainedMapGenerator.kt:79 */
|
1615 1979 | #[derive(Debug, Clone)]
|
1616 1980 | pub(crate) struct SparseLengthMapUnconstrained(
|
1617 1981 | pub(crate) std::collections::HashMap<
|
1618 1982 | ::std::string::String,
|
1619 1983 | ::std::option::Option<::std::string::String>,
|
1620 1984 | >,
|
1621 1985 | );
|
1622 1986 |
|
1623 1987 | impl From<SparseLengthMapUnconstrained>
|
1624 1988 | for crate::constrained::MaybeConstrained<crate::model::SparseLengthMap>
|
1625 1989 | {
|
1626 1990 | fn from(value: SparseLengthMapUnconstrained) -> Self {
|
1627 1991 | Self::Unconstrained(value)
|
1628 1992 | }
|
1629 1993 | }
|
1994 + | /* UnconstrainedMapGenerator.kt:101 */
|
1630 1995 | impl std::convert::TryFrom<SparseLengthMapUnconstrained> for crate::model::SparseLengthMap {
|
1996 + | /* UnconstrainedMapGenerator.kt:102 */
|
1631 1997 | type Error = crate::model::sparse_length_map_internal::ConstraintViolation;
|
1998 + | /* UnconstrainedMapGenerator.kt:104 */
|
1632 1999 | fn try_from(value: SparseLengthMapUnconstrained) -> std::result::Result<Self, Self::Error> {
|
2000 + | /* UnconstrainedMapGenerator.kt:241 */
|
1633 2001 | let hm = value.0;
|
2002 + | /* UnconstrainedMapGenerator.kt:245 */
|
1634 2003 | Self::try_from(hm)
|
2004 + | /* UnconstrainedMapGenerator.kt:104 */
|
1635 2005 | }
|
2006 + | /* UnconstrainedMapGenerator.kt:101 */
|
1636 2007 | }
|
2008 + |
|
2009 + | /* RustCrateInlineModuleComposingWriter.kt:299 */
|
1637 2010 | }
|
1638 2011 | pub(crate) mod sparse_list_unconstrained {
|
1639 2012 |
|
2013 + | /* UnconstrainedCollectionGenerator.kt:77 */
|
1640 2014 | #[derive(Debug, Clone)]
|
1641 2015 | pub(crate) struct SparseListUnconstrained(
|
1642 2016 | pub(crate) std::vec::Vec<::std::option::Option<::std::string::String>>,
|
1643 2017 | );
|
1644 2018 |
|
1645 2019 | impl From<SparseListUnconstrained>
|
1646 2020 | for crate::constrained::MaybeConstrained<
|
1647 2021 | crate::constrained::sparse_list_constrained::SparseListConstrained,
|
1648 2022 | >
|
1649 2023 | {
|
1650 2024 | fn from(value: SparseListUnconstrained) -> Self {
|
1651 2025 | Self::Unconstrained(value)
|
1652 2026 | }
|
1653 2027 | }
|
2028 + | /* UnconstrainedCollectionGenerator.kt:97 */
|
1654 2029 | impl std::convert::TryFrom<SparseListUnconstrained>
|
1655 2030 | for crate::constrained::sparse_list_constrained::SparseListConstrained
|
1656 2031 | {
|
2032 + | /* UnconstrainedCollectionGenerator.kt:98 */
|
1657 2033 | type Error = crate::model::sparse_list_internal::ConstraintViolation;
|
2034 + | /* UnconstrainedCollectionGenerator.kt:100 */
|
1658 2035 | fn try_from(value: SparseListUnconstrained) -> std::result::Result<Self, Self::Error> {
|
2036 + | /* UnconstrainedCollectionGenerator.kt:127 */
|
1659 2037 | let res: ::std::result::Result<
|
1660 2038 | ::std::vec::Vec<::std::option::Option<crate::model::LengthString>>,
|
1661 2039 | (
|
1662 2040 | usize,
|
1663 2041 | crate::model::length_string_internal::ConstraintViolation,
|
1664 2042 | ),
|
1665 2043 | > = value
|
1666 2044 | .0
|
1667 2045 | .into_iter()
|
1668 2046 | .enumerate()
|
1669 2047 | .map(|(idx, inner)| {
|
1670 2048 | inner
|
1671 2049 | .map(|inner| {
|
1672 2050 | inner
|
1673 2051 | .try_into()
|
1674 2052 | .map_err(|inner_violation| (idx, inner_violation))
|
1675 2053 | })
|
1676 2054 | .transpose()
|
1677 2055 | })
|
1678 2056 | .collect();
|
1679 2057 | let inner =
|
1680 2058 | res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
|
2059 + | /* UnconstrainedCollectionGenerator.kt:191 */
|
1681 2060 | Ok(Self(inner))
|
2061 + | /* UnconstrainedCollectionGenerator.kt:100 */
|
1682 2062 | }
|
2063 + | /* UnconstrainedCollectionGenerator.kt:97 */
|
1683 2064 | }
|
2065 + |
|
2066 + | /* RustCrateInlineModuleComposingWriter.kt:299 */
|
1684 2067 | }
|
1685 2068 | pub(crate) mod sparse_map_unconstrained {
|
1686 2069 |
|
2070 + | /* UnconstrainedMapGenerator.kt:79 */
|
1687 2071 | #[derive(Debug, Clone)]
|
1688 2072 | pub(crate) struct SparseMapUnconstrained(
|
1689 2073 | pub(crate) std::collections::HashMap<
|
1690 2074 | ::std::string::String,
|
1691 2075 | ::std::option::Option<
|
1692 2076 | crate::unconstrained::unique_items_list_unconstrained::UniqueItemsListUnconstrained,
|
1693 2077 | >,
|
1694 2078 | >,
|
1695 2079 | );
|
1696 2080 |
|
1697 2081 | impl From<SparseMapUnconstrained>
|
1698 2082 | for crate::constrained::MaybeConstrained<
|
1699 2083 | crate::constrained::sparse_map_constrained::SparseMapConstrained,
|
1700 2084 | >
|
1701 2085 | {
|
1702 2086 | fn from(value: SparseMapUnconstrained) -> Self {
|
1703 2087 | Self::Unconstrained(value)
|
1704 2088 | }
|
1705 2089 | }
|
2090 + | /* UnconstrainedMapGenerator.kt:101 */
|
1706 2091 | impl std::convert::TryFrom<SparseMapUnconstrained>
|
1707 2092 | for crate::constrained::sparse_map_constrained::SparseMapConstrained
|
1708 2093 | {
|
2094 + | /* UnconstrainedMapGenerator.kt:102 */
|
1709 2095 | type Error = crate::model::sparse_map_internal::ConstraintViolation;
|
2096 + | /* UnconstrainedMapGenerator.kt:104 */
|
1710 2097 | fn try_from(value: SparseMapUnconstrained) -> std::result::Result<Self, Self::Error> {
|
2098 + | /* UnconstrainedMapGenerator.kt:186 */
|
1711 2099 | let res: ::std::result::Result<
|
1712 2100 | ::std::collections::HashMap<
|
1713 2101 | ::std::string::String,
|
1714 2102 | ::std::option::Option<crate::model::UniqueItemsList>,
|
1715 2103 | >,
|
1716 2104 | Self::Error,
|
1717 2105 | > = value
|
1718 2106 | .0
|
1719 2107 | .into_iter()
|
1720 2108 | .map(|(k, v)| match v {
|
1721 2109 | None => Ok((k, None)),
|
1722 2110 | Some(v) => match crate::model::UniqueItemsList::try_from(v) {
|
1723 2111 | Ok(v) => Ok((k, Some(v))),
|
1724 2112 | Err(inner_constraint_violation) => {
|
1725 2113 | Err(Self::Error::Value(k, inner_constraint_violation))
|
1726 2114 | }
|
1727 2115 | },
|
1728 2116 | })
|
1729 2117 | .collect();
|
1730 2118 | let hm = res?;
|
2119 + | /* UnconstrainedMapGenerator.kt:247 */
|
1731 2120 | Ok(Self(hm))
|
2121 + | /* UnconstrainedMapGenerator.kt:104 */
|
1732 2122 | }
|
2123 + | /* UnconstrainedMapGenerator.kt:101 */
|
1733 2124 | }
|
2125 + |
|
2126 + | /* RustCrateInlineModuleComposingWriter.kt:299 */
|
1734 2127 | }
|
1735 2128 | pub(crate) mod unique_items_list_unconstrained {
|
1736 2129 |
|
2130 + | /* UnconstrainedCollectionGenerator.kt:77 */
|
1737 2131 | #[derive(Debug, Clone)]
|
1738 2132 | pub(crate) struct UniqueItemsListUnconstrained(pub(crate) std::vec::Vec<::std::string::String>);
|
1739 2133 |
|
1740 2134 | impl From<UniqueItemsListUnconstrained>
|
1741 2135 | for crate::constrained::MaybeConstrained<crate::model::UniqueItemsList>
|
1742 2136 | {
|
1743 2137 | fn from(value: UniqueItemsListUnconstrained) -> Self {
|
1744 2138 | Self::Unconstrained(value)
|
1745 2139 | }
|
1746 2140 | }
|
2141 + | /* UnconstrainedCollectionGenerator.kt:97 */
|
1747 2142 | impl std::convert::TryFrom<UniqueItemsListUnconstrained> for crate::model::UniqueItemsList {
|
2143 + | /* UnconstrainedCollectionGenerator.kt:98 */
|
1748 2144 | type Error = crate::model::unique_items_list_internal::ConstraintViolation;
|
2145 + | /* UnconstrainedCollectionGenerator.kt:100 */
|
1749 2146 | fn try_from(value: UniqueItemsListUnconstrained) -> std::result::Result<Self, Self::Error> {
|
2147 + | /* UnconstrainedCollectionGenerator.kt:185 */
|
1750 2148 | let inner = value.0;
|
2149 + | /* UnconstrainedCollectionGenerator.kt:189 */
|
1751 2150 | Self::try_from(inner)
|
2151 + | /* UnconstrainedCollectionGenerator.kt:100 */
|
1752 2152 | }
|
2153 + | /* UnconstrainedCollectionGenerator.kt:97 */
|
1753 2154 | }
|
2155 + |
|
2156 + | /* RustCrateInlineModuleComposingWriter.kt:299 */
|
1754 2157 | }
|
1755 2158 | pub(crate) mod map_of_map_of_list_of_list_of_con_b_unconstrained {
|
1756 2159 |
|
2160 + | /* UnconstrainedMapGenerator.kt:79 */
|
1757 2161 | #[derive(Debug, Clone)]
|
1758 2162 | pub(crate) struct MapOfMapOfListOfListOfConBUnconstrained(pub(crate) std::collections::HashMap<::std::string::String, crate::unconstrained::map_of_list_of_list_of_con_b_unconstrained::MapOfListOfListOfConBUnconstrained>);
|
1759 2163 |
|
1760 2164 | impl From<MapOfMapOfListOfListOfConBUnconstrained> for crate::constrained::MaybeConstrained<crate::constrained::map_of_map_of_list_of_list_of_con_b_constrained::MapOfMapOfListOfListOfConBConstrained> {
|
1761 2165 | fn from(value: MapOfMapOfListOfListOfConBUnconstrained) -> Self {
|
1762 2166 | Self::Unconstrained(value)
|
1763 2167 | }
|
1764 2168 | }
|
2169 + | /* UnconstrainedMapGenerator.kt:101 */
|
1765 2170 | impl std::convert::TryFrom<MapOfMapOfListOfListOfConBUnconstrained> for crate::constrained::map_of_map_of_list_of_list_of_con_b_constrained::MapOfMapOfListOfListOfConBConstrained {
|
1766 - | type Error = crate::model::map_of_map_of_list_of_list_of_con_b_internal::ConstraintViolation;
|
1767 - | fn try_from(value: MapOfMapOfListOfListOfConBUnconstrained) -> std::result::Result<Self, Self::Error> {
|
1768 - | 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
|
2171 + | /* UnconstrainedMapGenerator.kt:102 */type Error = crate::model::map_of_map_of_list_of_list_of_con_b_internal::ConstraintViolation;
|
2172 + | /* UnconstrainedMapGenerator.kt:104 */fn try_from(value: MapOfMapOfListOfListOfConBUnconstrained) -> std::result::Result<Self, Self::Error> {
|
2173 + | /* UnconstrainedMapGenerator.kt:186 */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
|
1769 2174 | .into_iter()
|
1770 2175 | .map(|(k, v)| {
|
1771 2176 | match crate::constrained::map_of_list_of_list_of_con_b_constrained::MapOfListOfListOfConBConstrained::try_from(v) {
|
1772 2177 | Ok(v) => Ok((k, v)),
|
1773 2178 | Err(inner_constraint_violation) => Err(Self::Error::Value(k, inner_constraint_violation)),
|
1774 2179 | }
|
1775 2180 | })
|
1776 2181 | .collect();
|
1777 2182 | let hm = res?;
|
1778 - | Ok(Self(hm))
|
1779 - | }
|
1780 - | }
|
2183 + | /* UnconstrainedMapGenerator.kt:247 */Ok(Self(hm))
|
2184 + | /* UnconstrainedMapGenerator.kt:104 */}
|
2185 + | /* UnconstrainedMapGenerator.kt:101 */}
|
2186 + |
|
2187 + | /* RustCrateInlineModuleComposingWriter.kt:299 */
|
1781 2188 | }
|
1782 2189 | pub(crate) mod map_of_list_of_list_of_con_b_unconstrained {
|
1783 2190 |
|
2191 + | /* UnconstrainedMapGenerator.kt:79 */
|
1784 2192 | #[derive(Debug, Clone)]
|
1785 2193 | pub(crate) struct MapOfListOfListOfConBUnconstrained(
|
1786 2194 | pub(crate) std::collections::HashMap<
|
1787 2195 | ::std::string::String,
|
1788 2196 | crate::unconstrained::con_b_list_unconstrained::ConBListUnconstrained,
|
1789 2197 | >,
|
1790 2198 | );
|
1791 2199 |
|
1792 2200 | impl From<MapOfListOfListOfConBUnconstrained> for crate::constrained::MaybeConstrained<crate::constrained::map_of_list_of_list_of_con_b_constrained::MapOfListOfListOfConBConstrained> {
|
1793 2201 | fn from(value: MapOfListOfListOfConBUnconstrained) -> Self {
|
1794 2202 | Self::Unconstrained(value)
|
1795 2203 | }
|
1796 2204 | }
|
2205 + | /* UnconstrainedMapGenerator.kt:101 */
|
1797 2206 | impl std::convert::TryFrom<MapOfListOfListOfConBUnconstrained> for crate::constrained::map_of_list_of_list_of_con_b_constrained::MapOfListOfListOfConBConstrained {
|
1798 - | type Error = crate::model::map_of_list_of_list_of_con_b_internal::ConstraintViolation;
|
1799 - | fn try_from(value: MapOfListOfListOfConBUnconstrained) -> std::result::Result<Self, Self::Error> {
|
1800 - | let res: ::std::result::Result<::std::collections::HashMap<::std::string::String, crate::constrained::con_b_list_constrained::ConBListConstrained>, Self::Error> = value.0
|
2207 + | /* UnconstrainedMapGenerator.kt:102 */type Error = crate::model::map_of_list_of_list_of_con_b_internal::ConstraintViolation;
|
2208 + | /* UnconstrainedMapGenerator.kt:104 */fn try_from(value: MapOfListOfListOfConBUnconstrained) -> std::result::Result<Self, Self::Error> {
|
2209 + | /* UnconstrainedMapGenerator.kt:186 */let res: ::std::result::Result<::std::collections::HashMap<::std::string::String, crate::constrained::con_b_list_constrained::ConBListConstrained>, Self::Error> = value.0
|
1801 2210 | .into_iter()
|
1802 2211 | .map(|(k, v)| {
|
1803 2212 | match crate::constrained::con_b_list_constrained::ConBListConstrained::try_from(v) {
|
1804 2213 | Ok(v) => Ok((k, v)),
|
1805 2214 | Err(inner_constraint_violation) => Err(Self::Error::Value(k, inner_constraint_violation)),
|
1806 2215 | }
|
1807 2216 | })
|
1808 2217 | .collect();
|
1809 2218 | let hm = res?;
|
1810 - | Ok(Self(hm))
|
1811 - | }
|
1812 - | }
|
2219 + | /* UnconstrainedMapGenerator.kt:247 */Ok(Self(hm))
|
2220 + | /* UnconstrainedMapGenerator.kt:104 */}
|
2221 + | /* UnconstrainedMapGenerator.kt:101 */}
|
2222 + |
|
2223 + | /* RustCrateInlineModuleComposingWriter.kt:299 */
|
1813 2224 | }
|
1814 2225 | pub(crate) mod length_map_unconstrained {
|
1815 2226 |
|
2227 + | /* UnconstrainedMapGenerator.kt:79 */
|
1816 2228 | #[derive(Debug, Clone)]
|
1817 2229 | pub(crate) struct LengthMapUnconstrained(
|
1818 2230 | pub(crate) std::collections::HashMap<::std::string::String, ::std::string::String>,
|
1819 2231 | );
|
1820 2232 |
|
1821 2233 | impl From<LengthMapUnconstrained>
|
1822 2234 | for crate::constrained::MaybeConstrained<crate::model::LengthMap>
|
1823 2235 | {
|
1824 2236 | fn from(value: LengthMapUnconstrained) -> Self {
|
1825 2237 | Self::Unconstrained(value)
|
1826 2238 | }
|
1827 2239 | }
|
2240 + | /* UnconstrainedMapGenerator.kt:101 */
|
1828 2241 | impl std::convert::TryFrom<LengthMapUnconstrained> for crate::model::LengthMap {
|
2242 + | /* UnconstrainedMapGenerator.kt:102 */
|
1829 2243 | type Error = crate::model::length_map_internal::ConstraintViolation;
|
2244 + | /* UnconstrainedMapGenerator.kt:104 */
|
1830 2245 | fn try_from(value: LengthMapUnconstrained) -> std::result::Result<Self, Self::Error> {
|
2246 + | /* UnconstrainedMapGenerator.kt:241 */
|
1831 2247 | let hm = value.0;
|
2248 + | /* UnconstrainedMapGenerator.kt:245 */
|
1832 2249 | Self::try_from(hm)
|
2250 + | /* UnconstrainedMapGenerator.kt:104 */
|
1833 2251 | }
|
2252 + | /* UnconstrainedMapGenerator.kt:101 */
|
1834 2253 | }
|
2254 + |
|
2255 + | /* RustCrateInlineModuleComposingWriter.kt:299 */
|
1835 2256 | }
|
1836 2257 | pub(crate) mod sensitive_length_list_unconstrained {
|
1837 2258 |
|
2259 + | /* UnconstrainedCollectionGenerator.kt:77 */
|
1838 2260 | #[derive(Debug, Clone)]
|
1839 2261 | pub(crate) struct SensitiveLengthListUnconstrained(
|
1840 2262 | pub(crate) std::vec::Vec<crate::model::SensitiveStructure>,
|
1841 2263 | );
|
1842 2264 |
|
1843 2265 | impl From<SensitiveLengthListUnconstrained>
|
1844 2266 | for crate::constrained::MaybeConstrained<crate::model::SensitiveLengthList>
|
1845 2267 | {
|
1846 2268 | fn from(value: SensitiveLengthListUnconstrained) -> Self {
|
1847 2269 | Self::Unconstrained(value)
|
1848 2270 | }
|
1849 2271 | }
|
2272 + | /* UnconstrainedCollectionGenerator.kt:97 */
|
1850 2273 | impl std::convert::TryFrom<SensitiveLengthListUnconstrained> for crate::model::SensitiveLengthList {
|
2274 + | /* UnconstrainedCollectionGenerator.kt:98 */
|
1851 2275 | type Error = crate::model::sensitive_length_list_internal::ConstraintViolation;
|
2276 + | /* UnconstrainedCollectionGenerator.kt:100 */
|
1852 2277 | fn try_from(
|
1853 2278 | value: SensitiveLengthListUnconstrained,
|
1854 2279 | ) -> std::result::Result<Self, Self::Error> {
|
2280 + | /* UnconstrainedCollectionGenerator.kt:185 */
|
1855 2281 | let inner = value.0;
|
2282 + | /* UnconstrainedCollectionGenerator.kt:189 */
|
1856 2283 | Self::try_from(inner)
|
2284 + | /* UnconstrainedCollectionGenerator.kt:100 */
|
1857 2285 | }
|
2286 + | /* UnconstrainedCollectionGenerator.kt:97 */
|
1858 2287 | }
|
2288 + |
|
2289 + | /* RustCrateInlineModuleComposingWriter.kt:299 */
|
1859 2290 | }
|
1860 2291 | pub(crate) mod length_list_unconstrained {
|
1861 2292 |
|
2293 + | /* UnconstrainedCollectionGenerator.kt:77 */
|
1862 2294 | #[derive(Debug, Clone)]
|
1863 2295 | pub(crate) struct LengthListUnconstrained(pub(crate) std::vec::Vec<::std::string::String>);
|
1864 2296 |
|
1865 2297 | impl From<LengthListUnconstrained>
|
1866 2298 | for crate::constrained::MaybeConstrained<crate::model::LengthList>
|
1867 2299 | {
|
1868 2300 | fn from(value: LengthListUnconstrained) -> Self {
|
1869 2301 | Self::Unconstrained(value)
|
1870 2302 | }
|
1871 2303 | }
|
2304 + | /* UnconstrainedCollectionGenerator.kt:97 */
|
1872 2305 | impl std::convert::TryFrom<LengthListUnconstrained> for crate::model::LengthList {
|
2306 + | /* UnconstrainedCollectionGenerator.kt:98 */
|
1873 2307 | type Error = crate::model::length_list_internal::ConstraintViolation;
|
2308 + | /* UnconstrainedCollectionGenerator.kt:100 */
|
1874 2309 | fn try_from(value: LengthListUnconstrained) -> std::result::Result<Self, Self::Error> {
|
2310 + | /* UnconstrainedCollectionGenerator.kt:185 */
|
1875 2311 | let inner = value.0;
|
2312 + | /* UnconstrainedCollectionGenerator.kt:189 */
|
1876 2313 | Self::try_from(inner)
|
2314 + | /* UnconstrainedCollectionGenerator.kt:100 */
|
1877 2315 | }
|
2316 + | /* UnconstrainedCollectionGenerator.kt:97 */
|
1878 2317 | }
|
2318 + |
|
2319 + | /* RustCrateInlineModuleComposingWriter.kt:299 */
|
1879 2320 | }
|