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