1#[allow(
2 non_camel_case_types,
3 non_snake_case,
4 non_upper_case_globals,
5 unused,
6 clippy::too_many_arguments
7)]
8pub mod aviaeinumbering_and_data_structures {
9 extern crate alloc;
10 use core::borrow::Borrow;
11
12 use rasn::prelude::*;
13 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
14 #[rasn(delegate, value("0..=63"))]
15 pub struct AlphabetIndicator(pub u8);
16 #[doc = " 6 bits, latinAlphabetNo1 recommended "]
17 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
18 #[rasn(delegate)]
19 pub struct AviEriDateTime(pub FixedOctetString<10usize>);
20 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
21 #[rasn(automatic_tags)]
22 pub struct CS1 {
23 #[rasn(identifier = "countryCode")]
24 pub country_code: CountryCode,
25 #[rasn(identifier = "issuerIdentifier")]
26 pub issuer_identifier: IssuerIdentifier,
27 #[rasn(identifier = "serviceNumber")]
28 pub service_number: ServiceNumber,
29 }
30 impl CS1 {
31 pub fn new(
32 country_code: CountryCode,
33 issuer_identifier: IssuerIdentifier,
34 service_number: ServiceNumber,
35 ) -> Self {
36 Self {
37 country_code,
38 issuer_identifier,
39 service_number,
40 }
41 }
42 }
43 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
44 #[rasn(automatic_tags)]
45 pub struct CS2 {
46 #[rasn(identifier = "manufacturerIdentifier")]
47 pub manufacturer_identifier: ManufacturerIdentifier,
48 #[rasn(identifier = "serviceNumber")]
49 pub service_number: ServiceNumber,
50 }
51 impl CS2 {
52 pub fn new(
53 manufacturer_identifier: ManufacturerIdentifier,
54 service_number: ServiceNumber,
55 ) -> Self {
56 Self {
57 manufacturer_identifier,
58 service_number,
59 }
60 }
61 }
62 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
63 #[rasn(automatic_tags)]
64 pub struct CS3 {
65 #[rasn(identifier = "startTime")]
66 pub start_time: StartTime,
67 #[rasn(identifier = "stopTime")]
68 pub stop_time: StopTime,
69 #[rasn(identifier = "geographLimit")]
70 pub geograph_limit: GeoGraphicalLimit,
71 #[rasn(identifier = "serviceAppLimit")]
72 pub service_app_limit: ServiceApplicationLimit,
73 }
74 impl CS3 {
75 pub fn new(
76 start_time: StartTime,
77 stop_time: StopTime,
78 geograph_limit: GeoGraphicalLimit,
79 service_app_limit: ServiceApplicationLimit,
80 ) -> Self {
81 Self {
82 start_time,
83 stop_time,
84 geograph_limit,
85 service_app_limit,
86 }
87 }
88 }
89
90 #[doc = "CS4::= SEQUENCE {"]
91 #[doc = "\tcountryCode \t\tCountryCode,"]
92 #[doc = "\talphabetIndicator \tAlphabetIndicator, "]
93 #[doc = "\tlicPlateNumber \t\tLicPlateNumber"]
94 #[doc = "\t}"]
95 #[doc = "\t"]
96 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
97 #[rasn(automatic_tags)]
98 pub struct CS4 {
99 #[rasn(identifier = "countryCode")]
100 pub country_code: CountryCode,
101 #[rasn(identifier = "alphabetIndicator")]
102 pub alphabet_indicator: AlphabetIndicator,
103 #[rasn(identifier = "licPlateNumber")]
104 pub lic_plate_number: LicPlateNumber,
105 }
106 impl CS4 {
107 pub fn new(
108 country_code: CountryCode,
109 alphabet_indicator: AlphabetIndicator,
110 lic_plate_number: LicPlateNumber,
111 ) -> Self {
112 Self {
113 country_code,
114 alphabet_indicator,
115 lic_plate_number,
116 }
117 }
118 }
119 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
120 #[rasn(automatic_tags)]
121 pub struct CS5 {
122 pub vin: VisibleString,
123 #[rasn(size("9"))]
124 pub fill: BitString,
125 }
126 impl CS5 {
127 pub fn new(vin: VisibleString, fill: BitString) -> Self {
128 Self { vin, fill }
129 }
130 }
131 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
132 #[rasn(delegate)]
133 pub struct CS7(pub FreightContainerData);
134 #[doc = " 12 octets"]
135 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
136 #[rasn(automatic_tags)]
137 pub struct CS8 {
138 #[rasn(size("6"))]
139 pub fill: BitString,
140 #[rasn(identifier = "countryCode")]
141 pub country_code: CountryCode,
142 #[rasn(identifier = "taxCode")]
143 pub tax_code: TaxCode,
144 }
145 impl CS8 {
146 pub fn new(fill: BitString, country_code: CountryCode, tax_code: TaxCode) -> Self {
147 Self {
148 fill,
149 country_code,
150 tax_code,
151 }
152 }
153 }
154 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
155 #[rasn(delegate)]
156 pub struct CountryCode(pub FixedBitString<10usize>);
157 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
158 #[rasn(automatic_tags)]
159 pub struct FreightContainerData {
160 #[rasn(size("19"), identifier = "ownerCode")]
161 pub owner_code: BitString,
162 #[rasn(value("0..=1000000"), identifier = "serialNumber")]
163 pub serial_number: u32,
164 #[rasn(value("0..=10"), identifier = "checkDigit")]
165 pub check_digit: u8,
166 #[rasn(value("1..=2000"))]
167 pub length: u16,
168 #[rasn(value("1..=500"))]
169 pub height: u16,
170 #[rasn(value("200..=300"))]
171 pub width: u16,
172 #[rasn(value("0..=127"), identifier = "containerTypeCode")]
173 pub container_type_code: u8,
174 #[rasn(value("19..=500"), identifier = "maximumGrossMass")]
175 pub maximum_gross_mass: u16,
176 #[rasn(value("0..=99"), identifier = "tareMass")]
177 pub tare_mass: u8,
178 #[rasn(size("3"))]
179 pub fill: BitString,
180 }
181 impl FreightContainerData {
182 pub fn new(
183 owner_code: BitString,
184 serial_number: u32,
185 check_digit: u8,
186 length: u16,
187 height: u16,
188 width: u16,
189 container_type_code: u8,
190 maximum_gross_mass: u16,
191 tare_mass: u8,
192 fill: BitString,
193 ) -> Self {
194 Self {
195 owner_code,
196 serial_number,
197 check_digit,
198 length,
199 height,
200 width,
201 container_type_code,
202 maximum_gross_mass,
203 tare_mass,
204 fill,
205 }
206 }
207 }
208 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
209 #[rasn(delegate)]
210 pub struct GeoGraphicalLimit(pub FixedBitString<8usize>);
211 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
212 #[rasn(delegate, value("0..=16383"))]
213 pub struct IssuerIdentifier(pub u16);
214 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
215 #[rasn(delegate)]
216 pub struct LicPlateNumber(pub OctetString);
217 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
218 #[rasn(delegate, value("0..=65535"))]
219 pub struct ManufacturerIdentifier(pub u16);
220 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
221 #[rasn(delegate)]
222 pub struct ServiceApplicationLimit(pub FixedBitString<8usize>);
223 #[doc = "ServiceNumber::= BIT STRING(SIZE(32))"]
224 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
225 #[rasn(delegate)]
226 pub struct ServiceNumber(pub FixedBitString<32usize>);
227 #[doc = " YYMMDDhhmm"]
228 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
229 #[rasn(delegate)]
230 pub struct StartTime(pub AviEriDateTime);
231 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
232 #[rasn(delegate)]
233 pub struct StopTime(pub AviEriDateTime);
234 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
235 #[rasn(delegate)]
236 pub struct TaxCode(pub OctetString);
237}
238#[allow(
239 non_camel_case_types,
240 non_snake_case,
241 non_upper_case_globals,
242 unused,
243 clippy::too_many_arguments
244)]
245pub mod citsappl_mgmt_ids {
246 extern crate alloc;
247 use core::borrow::Borrow;
248
249 use rasn::prelude::*;
250 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
251 #[rasn(choice)]
252 pub enum Ext1 {
253 #[rasn(value("128..=16511"), tag(context, 0))]
254 content(u16),
255 #[rasn(tag(context, 1))]
256 extension(Ext2),
257 }
258 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
259 #[rasn(choice)]
260 pub enum Ext2 {
261 #[rasn(value("16512..=2113663"), tag(context, 0))]
262 content(u32),
263 #[rasn(tag(context, 1))]
264 extension(Ext3),
265 }
266 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
267 #[rasn(delegate, value("2113664..=270549119", extensible))]
268 pub struct Ext3(pub Integer);
269 #[doc = " End of IMPORTS"]
270 #[doc = " Types"]
271 #[doc = " Variable length data types"]
272 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
273 #[rasn(choice)]
274 pub enum VarLengthNumber {
275 #[rasn(value("0..=127"), tag(context, 0))]
276 content(u8),
277 #[rasn(tag(context, 1))]
278 extension(Ext1),
279 }
280 #[doc = " four and more octets length"]
281 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
282 #[rasn(choice)]
283 pub enum VarLengthNumber2 {
284 #[rasn(value("0..=127"), tag(context, 0))]
285 shortNo(u8),
286 #[rasn(value("0..=32767"), tag(context, 1))]
287 longNo(u16),
288 }
289 #[doc = " Values"]
290 pub const VERSION: u8 = 1;
291}
292#[allow(
293 non_camel_case_types,
294 non_snake_case,
295 non_upper_case_globals,
296 unused,
297 clippy::too_many_arguments
298)]
299pub mod efc_dsrc_application {
300 extern crate alloc;
301 use core::borrow::Borrow;
302
303 use rasn::prelude::*;
304
305 use super::aviaeinumbering_and_data_structures::{CS5, CountryCode, IssuerIdentifier};
306 #[doc = " defined in ISO 14816 "]
307 #[doc = " NOTE: The following are the definitions of the action and response"]
308 #[doc = " parameters"]
309 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
310 #[rasn(automatic_tags)]
311 pub struct AxleWeightLimits {
312 #[rasn(identifier = "maxLadenweightOnAxle1")]
313 pub max_ladenweight_on_axle1: Int2,
314 #[rasn(identifier = "maxLadenweightOnAxle2")]
315 pub max_ladenweight_on_axle2: Int2,
316 #[rasn(identifier = "maxLadenweightOnAxle3")]
317 pub max_ladenweight_on_axle3: Int2,
318 #[rasn(identifier = "maxLadenweightOnAxle4")]
319 pub max_ladenweight_on_axle4: Int2,
320 #[rasn(identifier = "maxLadenweightOnAxle5")]
321 pub max_ladenweight_on_axle5: Int2,
322 }
323 impl AxleWeightLimits {
324 pub fn new(
325 max_ladenweight_on_axle1: Int2,
326 max_ladenweight_on_axle2: Int2,
327 max_ladenweight_on_axle3: Int2,
328 max_ladenweight_on_axle4: Int2,
329 max_ladenweight_on_axle5: Int2,
330 ) -> Self {
331 Self {
332 max_ladenweight_on_axle1,
333 max_ladenweight_on_axle2,
334 max_ladenweight_on_axle3,
335 max_ladenweight_on_axle4,
336 max_ladenweight_on_axle5,
337 }
338 }
339 }
340 #[doc = " 4 bits, EURO-Classes as defined in EC directive 88/77/EEC, annex 1"]
341 #[doc = " and in 91/542/EEC, 96/1/EC, 1999/96/EC, 2001/27/EC, regulation No 595/2009"]
342 #[doc = " and for EEV in Section 6.2.1 of Annex I in EC directive 2005/55/EC"]
343 #[doc = " EUR-Class VI as defined in Regulation (EC) No 595/2009"]
344 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
345 #[rasn(enumerated)]
346 pub enum CopValue {
347 noEntry = 0,
348 co2class1 = 1,
349 co2class2 = 2,
350 co2class3 = 3,
351 co2class4 = 4,
352 co2class5 = 5,
353 co2class6 = 6,
354 co2class7 = 7,
355 reservedforUse = 8,
356 }
357 #[doc = " NOTE: The following are the definitions of EFC attributes"]
358 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
359 #[rasn(automatic_tags)]
360 pub struct DateCompact {
361 #[rasn(value("1990..=2117"))]
362 pub year: u16,
363 #[rasn(value("0..=12"))]
364 pub month: u8,
365 #[rasn(value("0..=31"))]
366 pub day: u8,
367 }
368 impl DateCompact {
369 pub fn new(year: u16, month: u8, day: u8) -> Self {
370 Self { year, month, day }
371 }
372 }
373 #[doc = " Inner type "]
374 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
375 #[rasn(automatic_tags)]
376 pub struct DieselEmissionValuesParticulate {
377 #[rasn(identifier = "unitType")]
378 pub unit_type: UnitType,
379 #[rasn(value("0..=32767"))]
380 pub value: u16,
381 }
382 impl DieselEmissionValuesParticulate {
383 pub fn new(unit_type: UnitType, value: u16) -> Self {
384 Self { unit_type, value }
385 }
386 }
387 #[doc = " The value \"{year 1990, month 0, day 0}\" is a 16-bit all-zero"]
388 #[doc = " encoding, and is used to represent \"no date\"."]
389 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
390 #[rasn(automatic_tags)]
391 pub struct DieselEmissionValues {
392 pub particulate: DieselEmissionValuesParticulate,
393 #[rasn(identifier = "absorptionCoeff")]
394 pub absorption_coeff: Int2,
395 }
396 impl DieselEmissionValues {
397 pub fn new(particulate: DieselEmissionValuesParticulate, absorption_coeff: Int2) -> Self {
398 Self {
399 particulate,
400 absorption_coeff,
401 }
402 }
403 }
404 #[doc = " 4 bits, reserved for carbon dioxide pollution values as defined in"]
405 #[doc = " EC directive 2003/127/EC'"]
406 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
407 #[rasn(delegate, value("0..=255"))]
408 pub struct EngineCharacteristics(pub u8);
409 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
410 #[rasn(automatic_tags)]
411 pub struct EnvironmentalCharacteristics {
412 #[rasn(identifier = "euroValue")]
413 pub euro_value: EuroValue,
414 #[rasn(identifier = "copValue")]
415 pub cop_value: CopValue,
416 }
417 impl EnvironmentalCharacteristics {
418 pub fn new(euro_value: EuroValue, cop_value: CopValue) -> Self {
419 Self {
420 euro_value,
421 cop_value,
422 }
423 }
424 }
425 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
426 #[rasn(enumerated)]
427 pub enum EuroValue {
428 noEntry = 0,
429 #[rasn(identifier = "euro-1")]
430 euro_1 = 1,
431 #[rasn(identifier = "euro-2")]
432 euro_2 = 2,
433 #[rasn(identifier = "euro-3")]
434 euro_3 = 3,
435 #[rasn(identifier = "euro-4")]
436 euro_4 = 4,
437 #[rasn(identifier = "euro-5")]
438 euro_5 = 5,
439 #[rasn(identifier = "euro-6")]
440 euro_6 = 6,
441 reservedForUse1 = 7,
442 reservedForUse2 = 8,
443 reservedForUse3 = 9,
444 reservedForUse4 = 10,
445 reservedForUse5 = 11,
446 reservedForUse6 = 12,
447 reservedForUse7 = 13,
448 reservedForUse8 = 14,
449 eev = 15,
450 }
451 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
452 #[rasn(automatic_tags)]
453 pub struct ExhaustEmissionValues {
454 #[rasn(identifier = "unitType")]
455 pub unit_type: UnitType,
456 #[rasn(value("0..=32767"), identifier = "emissionCO")]
457 pub emission_co: u16,
458 #[rasn(identifier = "emissionHC")]
459 pub emission_hc: Int2,
460 #[rasn(identifier = "emissionNOX")]
461 pub emission_nox: Int2,
462 #[rasn(identifier = "emissionHCNOX")]
463 pub emission_hcnox: Int2,
464 }
465 impl ExhaustEmissionValues {
466 pub fn new(
467 unit_type: UnitType,
468 emission_co: u16,
469 emission_hc: Int2,
470 emission_nox: Int2,
471 emission_hcnox: Int2,
472 ) -> Self {
473 Self {
474 unit_type,
475 emission_co,
476 emission_hc,
477 emission_nox,
478 emission_hcnox,
479 }
480 }
481 }
482 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
483 #[rasn(delegate, value("0..=255"))]
484 pub struct Int1(pub u8);
485 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
486 #[rasn(delegate, value("0..=65535"))]
487 pub struct Int2(pub u16);
488 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
489 #[rasn(delegate, value("0..=16777215"))]
490 pub struct Int3(pub u32);
491 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
492 #[rasn(delegate, value("0..=4294967295"))]
493 pub struct Int4(pub u32);
494 #[doc = " Inner type "]
495 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
496 #[rasn(enumerated)]
497 pub enum LPNAlphabetIndicator {
498 latinAlphabetNo1 = 1,
499 latinAlphabetNo2 = 2,
500 latinAlphabetNo3 = 3,
501 latinAlphabetNo4 = 4,
502 latinCyrillicAlphabet = 5,
503 latinArabicAlphabet = 6,
504 latinGreekAlphabet = 7,
505 latinHebrewAlphabet = 8,
506 latinAlphabetNo5 = 9,
507 latinAlphabetNo6 = 10,
508 twoOctetBMP = 11,
509 fourOctetCanonical = 12,
510 reservedForUse1 = 13,
511 reservedForUse2 = 14,
512 reservedForUse3 = 15,
513 reservedForUse4 = 16,
514 reservedForUse5 = 17,
515 reservedForUse6 = 18,
516 reservedForUse7 = 19,
517 reservedForUse8 = 20,
518 reservedForUse9 = 21,
519 reservedForUse10 = 22,
520 reservedForUse11 = 23,
521 reservedForUse12 = 24,
522 reservedForUse13 = 25,
523 reservedForUse14 = 26,
524 reservedForUse15 = 27,
525 reservedForUse16 = 28,
526 reservedForUse17 = 29,
527 reservedForUse18 = 30,
528 reservedForUse19 = 31,
529 reservedForUse20 = 32,
530 reservedForUse21 = 33,
531 }
532 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
533 #[rasn(automatic_tags)]
534 pub struct LPN {
535 #[rasn(identifier = "countryCode")]
536 pub country_code: CountryCode,
537 #[rasn(identifier = "alphabetIndicator")]
538 pub alphabet_indicator: LPNAlphabetIndicator,
539 #[rasn(identifier = "licencePlateNumber")]
540 pub licence_plate_number: OctetString,
541 }
542 impl LPN {
543 pub fn new(
544 country_code: CountryCode,
545 alphabet_indicator: LPNAlphabetIndicator,
546 licence_plate_number: OctetString,
547 ) -> Self {
548 Self {
549 country_code,
550 alphabet_indicator,
551 licence_plate_number,
552 }
553 }
554 }
555 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
556 #[rasn(automatic_tags)]
557 pub struct PassengerCapacity {
558 #[rasn(identifier = "numberOfSeats")]
559 pub number_of_seats: Int1,
560 #[rasn(identifier = "numberOfStandingPlaces")]
561 pub number_of_standing_places: Int1,
562 }
563 impl PassengerCapacity {
564 pub fn new(number_of_seats: Int1, number_of_standing_places: Int1) -> Self {
565 Self {
566 number_of_seats,
567 number_of_standing_places,
568 }
569 }
570 }
571 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
572 #[rasn(delegate)]
573 pub struct PayUnit(pub FixedOctetString<2usize>);
574 #[doc = " corresponds to a �3 octets Signed Integer�, associated with the following"]
575 #[doc = " examples of line codes:"]
576 #[doc = " -8'388'608 : 80 00 00'H"]
577 #[doc = " -1 : FF FF FF'H"]
578 #[doc = " 0 : 00 00 00'H"]
579 #[doc = " 1 : 00 00 01�H"]
580 #[doc = " 8'388'607 : 7F FF FF'H"]
581 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
582 #[rasn(delegate)]
583 pub struct PaymentMeansUnit(pub PayUnit);
584 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
585 #[rasn(delegate)]
586 pub struct PaymentSecurityData(pub OctetString);
587 #[doc = " The unique designation of a Currency as defined in ISO 4217"]
588 #[doc = " using the ISO numeric binary coded decimal representation."]
589 #[doc = " The code can also express a company specific token or a"]
590 #[doc = " \"charging unit code\" as used in the freight.unit in which"]
591 #[doc = " the fee is expressed."]
592 #[doc = " Value Assignment :"]
593 #[doc = " '0xxx'H Currency in main units"]
594 #[doc = " '1xxx'H Currency in minor units of 10 :1 ('dime')"]
595 #[doc = " '2xxx'H Currency in minor units of 100 :1 ('cents')"]
596 #[doc = " '3xxx'H Currency in minor units of 1000 :1"]
597 #[doc = " '4xxx'H Currency in 'major' units / 10"]
598 #[doc = " (e.g. 10 Belgian Francs)"]
599 #[doc = " '5xxx'H Currency in 'major' units / 100"]
600 #[doc = " (e.g. 100 Italian Lire)"]
601 #[doc = " '6xxx'H Currency in 'major' units / 1000"]
602 #[doc = " '7xxx'H Currency in 'major' units / 10000"]
603 #[doc = " '8xxx'H Currency in 'major' units / 100000"]
604 #[doc = " where xxx is the BCD representation of \"Currency\""]
605 #[doc = " as defined in ISO 4217"]
606 #[doc = " '9xxx'H Tokens"]
607 #[doc = " where xxx is Purse Provider specific coding."]
608 #[doc = " 'Axxx'H Charging Unit Codes,"]
609 #[doc = " denoting quantification of the service provided"]
610 #[doc = " (e.g. man-hours)"]
611 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
612 #[rasn(delegate)]
613 pub struct PersonalAccountNumber(pub FixedOctetString<10usize>);
614 #[doc = " Personal account number structure � according to ISO/IEC 7812-1"]
615 #[doc = " Issuer identifier number (�BIN�)"]
616 #[doc = " Major industry identifier (MII, 1 binary coded decimal, BCD)"]
617 #[doc = " 0 : reserved for future use by ISO/TC68"]
618 #[doc = " 1 : airline sector"]
619 #[doc = " 2 : extended airline sector"]
620 #[doc = " 3 : travel and tourism sector"]
621 #[doc = " 4 : financial banking sector"]
622 #[doc = " 5 : financial banking sector"]
623 #[doc = " 6 : commerce and banking sector"]
624 #[doc = " 7 : petrol industry sector"]
625 #[doc = " 8 : telecommunication sector"]
626 #[doc = " 9 : reserved for national use"]
627 #[doc = " Issuer identifier (5 BCD in the second edition of ISO/IEC 7812-1)"]
628 #[doc = " Account number (max 12 BCD)"]
629 #[doc = " Control digit (1 BCD)"]
630 #[doc = " Padding bits, set to 1'B, in order to accomplish a"]
631 #[doc = " total length of 10 octets."]
632 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
633 #[rasn(automatic_tags)]
634 pub struct Provider {
635 #[rasn(identifier = "countryCode")]
636 pub country_code: CountryCode,
637 #[rasn(identifier = "providerIdentifier")]
638 pub provider_identifier: IssuerIdentifier,
639 }
640 impl Provider {
641 pub fn new(country_code: CountryCode, provider_identifier: IssuerIdentifier) -> Self {
642 Self {
643 country_code,
644 provider_identifier,
645 }
646 }
647 }
648 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
649 #[rasn(choice, automatic_tags)]
650 pub enum SignedValue {
651 #[rasn(value("0..=8388607"))]
652 positive(u32),
653 #[rasn(value("-8388608..=-1"))]
654 negative(i32),
655 }
656 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
657 #[rasn(automatic_tags)]
658 pub struct SoundLevel {
659 pub soundstationary: Int1,
660 pub sounddriveby: Int1,
661 }
662 impl SoundLevel {
663 pub fn new(soundstationary: Int1, sounddriveby: Int1) -> Self {
664 Self {
665 soundstationary,
666 sounddriveby,
667 }
668 }
669 }
670 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
671 #[rasn(enumerated)]
672 pub enum UnitType {
673 #[rasn(identifier = "mg-km")]
674 mg_km = 0,
675 #[rasn(identifier = "mg-kWh")]
676 mg_kWh = 1,
677 }
678 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
679 #[rasn(automatic_tags)]
680 pub struct VehicleDimensions {
681 #[rasn(identifier = "vehicleLengthOverall")]
682 pub vehicle_length_overall: Int1,
683 #[rasn(identifier = "vehicleHeigthOverall")]
684 pub vehicle_heigth_overall: Int1,
685 #[rasn(identifier = "vehicleWidthOverall")]
686 pub vehicle_width_overall: Int1,
687 }
688 impl VehicleDimensions {
689 pub fn new(
690 vehicle_length_overall: Int1,
691 vehicle_heigth_overall: Int1,
692 vehicle_width_overall: Int1,
693 ) -> Self {
694 Self {
695 vehicle_length_overall,
696 vehicle_heigth_overall,
697 vehicle_width_overall,
698 }
699 }
700 }
701 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
702 #[rasn(automatic_tags)]
703 pub struct VehicleWeightLimits {
704 #[rasn(identifier = "vehicleMaxLadenWeight")]
705 pub vehicle_max_laden_weight: Int2,
706 #[rasn(identifier = "vehicleTrainMaximumWeight")]
707 pub vehicle_train_maximum_weight: Int2,
708 #[rasn(identifier = "vehicleWeightUnladen")]
709 pub vehicle_weight_unladen: Int2,
710 }
711 impl VehicleWeightLimits {
712 pub fn new(
713 vehicle_max_laden_weight: Int2,
714 vehicle_train_maximum_weight: Int2,
715 vehicle_weight_unladen: Int2,
716 ) -> Self {
717 Self {
718 vehicle_max_laden_weight,
719 vehicle_train_maximum_weight,
720 vehicle_weight_unladen,
721 }
722 }
723 }
724}
725#[allow(
726 non_camel_case_types,
727 non_snake_case,
728 non_upper_case_globals,
729 unused,
730 clippy::too_many_arguments
731)]
732pub mod electronic_registration_identification_vehicle_data_module {
733 extern crate alloc;
734 use core::borrow::Borrow;
735
736 use rasn::prelude::*;
737 #[doc = " Electronic Registration Identification (ERI)- Vehicle Data"]
738 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
739 #[rasn(choice, automatic_tags)]
740 pub enum EuVehicleCategoryCode {
741 euVehicleCategoryL(EuVehicleCategoryL),
742 euVehicleCategoryM(EuVehicleCategoryM),
743 euVehicleCategoryN(EuVehicleCategoryN),
744 euVehicleCategoryO(EuVehicleCategoryO),
745 euVehilcleCategoryT(()),
746 euVehilcleCategoryG(()),
747 }
748 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
749 #[rasn(enumerated)]
750 pub enum EuVehicleCategoryL {
751 l1 = 0,
752 l2 = 1,
753 l3 = 2,
754 l4 = 3,
755 l5 = 4,
756 l6 = 5,
757 l7 = 6,
758 }
759 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
760 #[rasn(enumerated)]
761 pub enum EuVehicleCategoryM {
762 m1 = 0,
763 m2 = 1,
764 m3 = 2,
765 }
766 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
767 #[rasn(enumerated)]
768 pub enum EuVehicleCategoryN {
769 n1 = 0,
770 n2 = 1,
771 n3 = 2,
772 }
773 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
774 #[rasn(enumerated)]
775 pub enum EuVehicleCategoryO {
776 o1 = 0,
777 o2 = 1,
778 o3 = 2,
779 o4 = 3,
780 }
781 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
782 #[rasn(delegate, value("0..=255"))]
783 pub struct Iso3833VehicleType(pub u8);
784}
785#[allow(
786 non_camel_case_types,
787 non_snake_case,
788 non_upper_case_globals,
789 unused,
790 clippy::too_many_arguments
791)]
792pub mod gdd {
793 extern crate alloc;
794 use core::borrow::Borrow;
795
796 use rasn::prelude::*;
797 #[doc = " Definition of data elements used in ISO 14823 attributes"]
798 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
799 #[rasn(delegate, identifier = "Code-Units", value("0..=15"))]
800 pub struct CodeUnits(pub u8);
801 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
802 #[rasn(automatic_tags, identifier = "DDD-IO")]
803 pub struct DDDIO {
804 #[rasn(value("0..=7"), identifier = "arrowDirection")]
805 pub arrow_direction: u8,
806 #[rasn(identifier = "destPlace")]
807 pub dest_place: Option<DestinationPlaces>,
808 #[rasn(identifier = "destRoad")]
809 pub dest_road: Option<DestinationRoads>,
810 #[rasn(value("1..=999"), identifier = "roadNumberIdentifier")]
811 pub road_number_identifier: Option<u16>,
812 #[rasn(value("1..=999"), identifier = "streetName")]
813 pub street_name: Option<u16>,
814 #[rasn(identifier = "streetNameText")]
815 pub street_name_text: Option<Utf8String>,
816 #[rasn(identifier = "distanceToDivergingPoint")]
817 pub distance_to_diverging_point: Option<DistanceOrDuration>,
818 #[rasn(identifier = "distanceToDestinationPlace")]
819 pub distance_to_destination_place: Option<DistanceOrDuration>,
820 }
821 impl DDDIO {
822 pub fn new(
823 arrow_direction: u8,
824 dest_place: Option<DestinationPlaces>,
825 dest_road: Option<DestinationRoads>,
826 road_number_identifier: Option<u16>,
827 street_name: Option<u16>,
828 street_name_text: Option<Utf8String>,
829 distance_to_diverging_point: Option<DistanceOrDuration>,
830 distance_to_destination_place: Option<DistanceOrDuration>,
831 ) -> Self {
832 Self {
833 arrow_direction,
834 dest_place,
835 dest_road,
836 road_number_identifier,
837 street_name,
838 street_name_text,
839 distance_to_diverging_point,
840 distance_to_destination_place,
841 }
842 }
843 }
844 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
845 #[rasn(delegate, size("1..=8", extensible), identifier = "DDD-IO-LIST")]
846 pub struct DDDIOLIST(pub SequenceOf<DDDIO>);
847 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
848 #[rasn(delegate)]
849 pub struct DayOfWeek(pub FixedBitString<8usize>);
850 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
851 #[rasn(automatic_tags)]
852 pub struct DestinationPlace {
853 #[rasn(identifier = "destType")]
854 pub dest_type: DestinationType,
855 #[rasn(value("0.."), identifier = "destRSCode")]
856 pub dest_rscode: Option<GddStructure>,
857 #[rasn(identifier = "destBlob")]
858 pub dest_blob: Option<OctetString>,
859 #[rasn(value("1..=999"), identifier = "placeNameIdentification")]
860 pub place_name_identification: Option<u16>,
861 #[rasn(identifier = "placeNameText")]
862 pub place_name_text: Option<Utf8String>,
863 }
864 impl DestinationPlace {
865 pub fn new(
866 dest_type: DestinationType,
867 dest_rscode: Option<GddStructure>,
868 dest_blob: Option<OctetString>,
869 place_name_identification: Option<u16>,
870 place_name_text: Option<Utf8String>,
871 ) -> Self {
872 Self {
873 dest_type,
874 dest_rscode,
875 dest_blob,
876 place_name_identification,
877 place_name_text,
878 }
879 }
880 }
881 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
882 #[rasn(delegate, size("1..=4", extensible))]
883 pub struct DestinationPlaces(pub SequenceOf<DestinationPlace>);
884 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
885 #[rasn(automatic_tags)]
886 pub struct DestinationRoad {
887 #[rasn(identifier = "derType")]
888 pub der_type: DestinationRoadType,
889 #[rasn(value("1..=999"), identifier = "roadNumberIdentifier")]
890 pub road_number_identifier: Option<u16>,
891 #[rasn(identifier = "roadNumberText")]
892 pub road_number_text: Option<Utf8String>,
893 }
894 impl DestinationRoad {
895 pub fn new(
896 der_type: DestinationRoadType,
897 road_number_identifier: Option<u16>,
898 road_number_text: Option<Utf8String>,
899 ) -> Self {
900 Self {
901 der_type,
902 road_number_identifier,
903 road_number_text,
904 }
905 }
906 }
907 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
908 #[rasn(delegate, value("0..=15", extensible))]
909 pub struct DestinationRoadType(pub Integer);
910 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
911 #[rasn(delegate, size("1..=4", extensible))]
912 pub struct DestinationRoads(pub SequenceOf<DestinationRoad>);
913 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
914 #[rasn(delegate, value("0..=15", extensible))]
915 pub struct DestinationType(pub Integer);
916 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
917 #[rasn(automatic_tags)]
918 pub struct Distance {
919 #[rasn(value("1..=16384"))]
920 pub value: u16,
921 #[rasn(value("2..=8"))]
922 pub unit: CodeUnits,
923 }
924 impl Distance {
925 pub fn new(value: u16, unit: CodeUnits) -> Self {
926 Self { value, unit }
927 }
928 }
929 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
930 #[rasn(automatic_tags)]
931 pub struct DistanceOrDuration {
932 #[rasn(value("1..=16384"))]
933 pub value: u16,
934 #[rasn(value("2..=9"))]
935 pub unit: CodeUnits,
936 }
937 impl DistanceOrDuration {
938 pub fn new(value: u16, unit: CodeUnits) -> Self {
939 Self { value, unit }
940 }
941 }
942 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
943 #[rasn(choice, automatic_tags)]
944 pub enum GddAttribute {
945 dtm(InternationalSignApplicablePeriod),
946 edt(InternationalSignExemptedApplicablePeriod),
947 dfl(InternationalSignDirectionalFlowOfLane),
948 ved(InternationalSignApplicableVehicleDimensions),
949 spe(InternationalSignSpeedLimits),
950 roi(InternationalSignRateOfIncline),
951 dbv(InternationalSignDistanceBetweenVehicles),
952 ddd(InternationalSignDestinationInformation),
953 set(InternationalSignSection),
954 nol(InternationalSignNumberOfLane),
955 }
956 #[doc = " Definition of the single ISO 14823 Attributes"]
957 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
958 #[rasn(delegate, size("1..=8", extensible))]
959 pub struct GddAttributes(pub SequenceOf<GddAttribute>);
960 #[doc = " Inner type "]
961 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
962 #[rasn(enumerated)]
963 #[non_exhaustive]
964 pub enum GddStructurePictogramCodeServiceCategoryCodeTrafficSignPictogram {
965 dangerWarning = 0,
966 regulatory = 1,
967 informative = 2,
968 }
969 #[doc = " Inner type "]
970 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
971 #[rasn(enumerated)]
972 #[non_exhaustive]
973 pub enum GddStructurePictogramCodeServiceCategoryCodePublicFacilitiesPictogram {
974 publicFacilities = 0,
975 }
976 #[doc = " Inner type "]
977 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
978 #[rasn(enumerated)]
979 #[non_exhaustive]
980 pub enum GddStructurePictogramCodeServiceCategoryCodeAmbientOrRoadConditionPictogram {
981 ambientCondition = 0,
982 roadCondition = 1,
983 }
984 #[doc = " Inner type "]
985 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
986 #[rasn(choice, automatic_tags)]
987 #[non_exhaustive]
988 pub enum GddStructurePictogramCodeServiceCategoryCode {
989 trafficSignPictogram(GddStructurePictogramCodeServiceCategoryCodeTrafficSignPictogram),
990 publicFacilitiesPictogram(
991 GddStructurePictogramCodeServiceCategoryCodePublicFacilitiesPictogram,
992 ),
993 ambientOrRoadConditionPictogram(
994 GddStructurePictogramCodeServiceCategoryCodeAmbientOrRoadConditionPictogram,
995 ),
996 }
997 #[doc = " Inner type "]
998 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
999 #[rasn(automatic_tags)]
1000 pub struct GddStructurePictogramCodePictogramCategoryCode {
1001 #[rasn(value("1..=9"))]
1002 pub nature: u8,
1003 #[rasn(value("0..=99"), identifier = "serialNumber")]
1004 pub serial_number: u8,
1005 }
1006 impl GddStructurePictogramCodePictogramCategoryCode {
1007 pub fn new(nature: u8, serial_number: u8) -> Self {
1008 Self {
1009 nature,
1010 serial_number,
1011 }
1012 }
1013 }
1014 #[doc = " Inner type "]
1015 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1016 #[rasn(automatic_tags)]
1017 pub struct GddStructurePictogramCode {
1018 #[rasn(size("2"), identifier = "countryCode")]
1019 pub country_code: Option<OctetString>,
1020 #[rasn(identifier = "serviceCategoryCode")]
1021 pub service_category_code: GddStructurePictogramCodeServiceCategoryCode,
1022 #[rasn(identifier = "pictogramCategoryCode")]
1023 pub pictogram_category_code: GddStructurePictogramCodePictogramCategoryCode,
1024 }
1025 impl GddStructurePictogramCode {
1026 pub fn new(
1027 country_code: Option<OctetString>,
1028 service_category_code: GddStructurePictogramCodeServiceCategoryCode,
1029 pictogram_category_code: GddStructurePictogramCodePictogramCategoryCode,
1030 ) -> Self {
1031 Self {
1032 country_code,
1033 service_category_code,
1034 pictogram_category_code,
1035 }
1036 }
1037 }
1038 #[doc = "Definition of GDD Structure"]
1039 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1040 #[rasn(automatic_tags)]
1041 pub struct GddStructure {
1042 #[rasn(identifier = "pictogramCode")]
1043 pub pictogram_code: GddStructurePictogramCode,
1044 pub attributes: Option<GddAttributes>,
1045 }
1046 impl GddStructure {
1047 pub fn new(
1048 pictogram_code: GddStructurePictogramCode,
1049 attributes: Option<GddAttributes>,
1050 ) -> Self {
1051 Self {
1052 pictogram_code,
1053 attributes,
1054 }
1055 }
1056 }
1057 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1058 #[rasn(automatic_tags)]
1059 pub struct HoursMinutes {
1060 #[rasn(value("0..=23"))]
1061 pub hours: u8,
1062 #[rasn(value("0..=59"))]
1063 pub mins: u8,
1064 }
1065 impl HoursMinutes {
1066 pub fn new(hours: u8, mins: u8) -> Self {
1067 Self { hours, mins }
1068 }
1069 }
1070 #[doc = " Inner type "]
1071 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1072 #[rasn(automatic_tags)]
1073 pub struct InternationalSignApplicablePeriodYear {
1074 #[rasn(value("2000..=2127", extensible), identifier = "yearRangeStartYear")]
1075 pub year_range_start_year: Integer,
1076 #[rasn(value("2000..=2127", extensible), identifier = "yearRangeEndYear")]
1077 pub year_range_end_year: Integer,
1078 }
1079 impl InternationalSignApplicablePeriodYear {
1080 pub fn new(year_range_start_year: Integer, year_range_end_year: Integer) -> Self {
1081 Self {
1082 year_range_start_year,
1083 year_range_end_year,
1084 }
1085 }
1086 }
1087 #[doc = " Inner type "]
1088 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1089 #[rasn(automatic_tags)]
1090 pub struct InternationalSignApplicablePeriodMonthDay {
1091 #[rasn(identifier = "dateRangeStartMonthDay")]
1092 pub date_range_start_month_day: MonthDay,
1093 #[rasn(identifier = "dateRangeEndMonthDay")]
1094 pub date_range_end_month_day: MonthDay,
1095 }
1096 impl InternationalSignApplicablePeriodMonthDay {
1097 pub fn new(
1098 date_range_start_month_day: MonthDay,
1099 date_range_end_month_day: MonthDay,
1100 ) -> Self {
1101 Self {
1102 date_range_start_month_day,
1103 date_range_end_month_day,
1104 }
1105 }
1106 }
1107 #[doc = " Inner type "]
1108 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1109 #[rasn(automatic_tags)]
1110 pub struct InternationalSignApplicablePeriodHourMinutes {
1111 #[rasn(identifier = "timeRangeStartTime")]
1112 pub time_range_start_time: HoursMinutes,
1113 #[rasn(identifier = "timeRangeEndTime")]
1114 pub time_range_end_time: HoursMinutes,
1115 }
1116 impl InternationalSignApplicablePeriodHourMinutes {
1117 pub fn new(time_range_start_time: HoursMinutes, time_range_end_time: HoursMinutes) -> Self {
1118 Self {
1119 time_range_start_time,
1120 time_range_end_time,
1121 }
1122 }
1123 }
1124 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1125 #[rasn(automatic_tags, identifier = "InternationalSign-applicablePeriod")]
1126 pub struct InternationalSignApplicablePeriod {
1127 pub year: Option<InternationalSignApplicablePeriodYear>,
1128 #[rasn(identifier = "month-day")]
1129 pub month_day: Option<InternationalSignApplicablePeriodMonthDay>,
1130 #[rasn(identifier = "repeatingPeriodDayTypes")]
1131 pub repeating_period_day_types: Option<RepeatingPeriodDayTypes>,
1132 #[rasn(identifier = "hourMinutes")]
1133 pub hour_minutes: Option<InternationalSignApplicablePeriodHourMinutes>,
1134 #[rasn(identifier = "dateRangeOfWeek")]
1135 pub date_range_of_week: Option<DayOfWeek>,
1136 #[rasn(identifier = "durationHourMinute")]
1137 pub duration_hour_minute: Option<HoursMinutes>,
1138 }
1139 impl InternationalSignApplicablePeriod {
1140 pub fn new(
1141 year: Option<InternationalSignApplicablePeriodYear>,
1142 month_day: Option<InternationalSignApplicablePeriodMonthDay>,
1143 repeating_period_day_types: Option<RepeatingPeriodDayTypes>,
1144 hour_minutes: Option<InternationalSignApplicablePeriodHourMinutes>,
1145 date_range_of_week: Option<DayOfWeek>,
1146 duration_hour_minute: Option<HoursMinutes>,
1147 ) -> Self {
1148 Self {
1149 year,
1150 month_day,
1151 repeating_period_day_types,
1152 hour_minutes,
1153 date_range_of_week,
1154 duration_hour_minute,
1155 }
1156 }
1157 }
1158 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1159 #[rasn(
1160 automatic_tags,
1161 identifier = "InternationalSign-applicableVehicleDimensions"
1162 )]
1163 pub struct InternationalSignApplicableVehicleDimensions {
1164 #[rasn(identifier = "vehicleHeight")]
1165 pub vehicle_height: Option<Distance>,
1166 #[rasn(identifier = "vehicleWidth")]
1167 pub vehicle_width: Option<Distance>,
1168 #[rasn(identifier = "vehicleLength")]
1169 pub vehicle_length: Option<Distance>,
1170 #[rasn(identifier = "vehicleWeight")]
1171 pub vehicle_weight: Option<Weight>,
1172 }
1173 impl InternationalSignApplicableVehicleDimensions {
1174 pub fn new(
1175 vehicle_height: Option<Distance>,
1176 vehicle_width: Option<Distance>,
1177 vehicle_length: Option<Distance>,
1178 vehicle_weight: Option<Weight>,
1179 ) -> Self {
1180 Self {
1181 vehicle_height,
1182 vehicle_width,
1183 vehicle_length,
1184 vehicle_weight,
1185 }
1186 }
1187 }
1188 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1189 #[rasn(
1190 automatic_tags,
1191 identifier = "InternationalSign-destinationInformation"
1192 )]
1193 pub struct InternationalSignDestinationInformation {
1194 #[rasn(value("1..=128"), identifier = "junctionDirection")]
1195 pub junction_direction: Option<u8>,
1196 #[rasn(value("1..=128"), identifier = "roundaboutCwDirection")]
1197 pub roundabout_cw_direction: Option<u8>,
1198 #[rasn(value("1..=128"), identifier = "roundaboutCcwDirection")]
1199 pub roundabout_ccw_direction: Option<u8>,
1200 #[rasn(identifier = "ioList")]
1201 pub io_list: DDDIOLIST,
1202 }
1203 impl InternationalSignDestinationInformation {
1204 pub fn new(
1205 junction_direction: Option<u8>,
1206 roundabout_cw_direction: Option<u8>,
1207 roundabout_ccw_direction: Option<u8>,
1208 io_list: DDDIOLIST,
1209 ) -> Self {
1210 Self {
1211 junction_direction,
1212 roundabout_cw_direction,
1213 roundabout_ccw_direction,
1214 io_list,
1215 }
1216 }
1217 }
1218 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1219 #[rasn(
1220 delegate,
1221 identifier = "InternationalSign-directionalFlowOfLane",
1222 value("1..=8")
1223 )]
1224 pub struct InternationalSignDirectionalFlowOfLane(pub u8);
1225 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1226 #[rasn(delegate, identifier = "InternationalSign-distanceBetweenVehicles")]
1227 pub struct InternationalSignDistanceBetweenVehicles(pub Distance);
1228 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1229 #[rasn(delegate, identifier = "InternationalSign-exemptedApplicablePeriod")]
1230 pub struct InternationalSignExemptedApplicablePeriod(pub InternationalSignApplicablePeriod);
1231 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1232 #[rasn(
1233 delegate,
1234 identifier = "InternationalSign-numberOfLane",
1235 value("0..=99")
1236 )]
1237 pub struct InternationalSignNumberOfLane(pub u8);
1238 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1239 #[rasn(
1240 delegate,
1241 identifier = "InternationalSign-rateOfIncline",
1242 value("1..=32")
1243 )]
1244 pub struct InternationalSignRateOfIncline(pub u8);
1245 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1246 #[rasn(automatic_tags, identifier = "InternationalSign-section")]
1247 pub struct InternationalSignSection {
1248 #[rasn(identifier = "startingPointLength")]
1249 pub starting_point_length: Option<Distance>,
1250 #[rasn(identifier = "continuityLength")]
1251 pub continuity_length: Option<Distance>,
1252 }
1253 impl InternationalSignSection {
1254 pub fn new(
1255 starting_point_length: Option<Distance>,
1256 continuity_length: Option<Distance>,
1257 ) -> Self {
1258 Self {
1259 starting_point_length,
1260 continuity_length,
1261 }
1262 }
1263 }
1264 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1265 #[rasn(automatic_tags, identifier = "InternationalSign-speedLimits")]
1266 pub struct InternationalSignSpeedLimits {
1267 #[rasn(value("0..=250"), identifier = "speedLimitMax")]
1268 pub speed_limit_max: Option<u8>,
1269 #[rasn(value("0..=250"), identifier = "speedLimitMin")]
1270 pub speed_limit_min: Option<u8>,
1271 #[rasn(value("0..=1"))]
1272 pub unit: CodeUnits,
1273 }
1274 impl InternationalSignSpeedLimits {
1275 pub fn new(
1276 speed_limit_max: Option<u8>,
1277 speed_limit_min: Option<u8>,
1278 unit: CodeUnits,
1279 ) -> Self {
1280 Self {
1281 speed_limit_max,
1282 speed_limit_min,
1283 unit,
1284 }
1285 }
1286 }
1287 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1288 #[rasn(automatic_tags)]
1289 pub struct MonthDay {
1290 #[rasn(value("1..=12"))]
1291 pub month: u8,
1292 #[rasn(value("1..=31"))]
1293 pub day: u8,
1294 }
1295 impl MonthDay {
1296 pub fn new(month: u8, day: u8) -> Self {
1297 Self { month, day }
1298 }
1299 }
1300 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1301 #[rasn(delegate)]
1302 pub struct RepeatingPeriodDayTypes(pub FixedBitString<4usize>);
1303 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1304 #[rasn(automatic_tags)]
1305 pub struct Weight {
1306 #[rasn(value("1..=16384"))]
1307 pub value: u16,
1308 #[rasn(value("10..=12"))]
1309 pub unit: CodeUnits,
1310 }
1311 impl Weight {
1312 pub fn new(value: u16, unit: CodeUnits) -> Self {
1313 Self { value, unit }
1314 }
1315 }
1316}
1317#[allow(
1318 non_camel_case_types,
1319 non_snake_case,
1320 non_upper_case_globals,
1321 unused,
1322 clippy::too_many_arguments
1323)]
1324pub mod ivi {
1325 extern crate alloc;
1326 use core::borrow::Borrow;
1327
1328 use rasn::prelude::*;
1329
1330 use super::super::cdd_1_3_1_1::its_container::{
1331 ActionID,
1332 Altitude,
1333 DangerousGoodsBasic,
1334 DeltaLatitude,
1335 DeltaLongitude,
1336 DeltaReferencePosition,
1337 Heading,
1338 HeadingValue,
1339 LanePosition,
1340 Latitude,
1341 Longitude,
1342 ReferencePosition,
1343 RoadType,
1344 SpecialTransportType,
1345 Speed,
1346 SpeedValue,
1347 StationType,
1348 TimestampIts,
1349 VehicleRole,
1350 };
1351 use super::super::dsrc_2_2_1::etsi_its_dsrc::{
1352 IntersectionReferenceID,
1353 LaneID,
1354 RoadSegmentReferenceID,
1355 };
1356 use super::citsappl_mgmt_ids::VarLengthNumber;
1357 use super::efc_dsrc_application::{
1358 AxleWeightLimits,
1359 DieselEmissionValues,
1360 EngineCharacteristics,
1361 EnvironmentalCharacteristics,
1362 ExhaustEmissionValues,
1363 PassengerCapacity,
1364 Provider,
1365 SoundLevel,
1366 VehicleDimensions,
1367 VehicleWeightLimits,
1368 };
1369 use super::electronic_registration_identification_vehicle_data_module::{
1370 EuVehicleCategoryCode,
1371 Iso3833VehicleType,
1372 };
1373 use super::gdd::{
1374 InternationalSignApplicablePeriod,
1375 InternationalSignApplicableVehicleDimensions,
1376 InternationalSignDestinationInformation,
1377 InternationalSignDirectionalFlowOfLane,
1378 InternationalSignDistanceBetweenVehicles,
1379 InternationalSignExemptedApplicablePeriod,
1380 InternationalSignRateOfIncline,
1381 InternationalSignSpeedLimits,
1382 };
1383 #[doc = " Definition of Data Frames"]
1384 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1385 #[rasn(automatic_tags)]
1386 pub struct AbsolutePosition {
1387 pub latitude: Latitude,
1388 pub longitude: Longitude,
1389 }
1390 impl AbsolutePosition {
1391 pub fn new(latitude: Latitude, longitude: Longitude) -> Self {
1392 Self {
1393 latitude,
1394 longitude,
1395 }
1396 }
1397 }
1398 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1399 #[rasn(automatic_tags)]
1400 pub struct AbsolutePositionWAltitude {
1401 pub latitude: Latitude,
1402 pub longitude: Longitude,
1403 pub altitude: Altitude,
1404 }
1405 impl AbsolutePositionWAltitude {
1406 pub fn new(latitude: Latitude, longitude: Longitude, altitude: Altitude) -> Self {
1407 Self {
1408 latitude,
1409 longitude,
1410 altitude,
1411 }
1412 }
1413 }
1414 #[doc = " Definition of data frames which are lists of data frames"]
1415 #[doc = " note: those definitions are to avoid \"implicit type definitions\" but are bit compatible with V1"]
1416 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1417 #[rasn(delegate, size("1..=8", extensible))]
1418 pub struct AbsolutePositions(pub SequenceOf<AbsolutePosition>);
1419 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1420 #[rasn(delegate, size("1..=8", extensible))]
1421 pub struct AbsolutePositionsWAltitude(pub SequenceOf<AbsolutePositionWAltitude>);
1422 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1423 #[rasn(automatic_tags)]
1424 pub struct AnyCatalogue {
1425 pub owner: Provider,
1426 #[rasn(value("0..=255"))]
1427 pub version: u8,
1428 #[rasn(value("0..=65535"), identifier = "pictogramCode")]
1429 pub pictogram_code: u16,
1430 #[rasn(value("0..=65535"))]
1431 pub value: Option<u16>,
1432 pub unit: Option<RSCUnit>,
1433 pub attributes: Option<ISO14823Attributes>,
1434 }
1435 impl AnyCatalogue {
1436 pub fn new(
1437 owner: Provider,
1438 version: u8,
1439 pictogram_code: u16,
1440 value: Option<u16>,
1441 unit: Option<RSCUnit>,
1442 attributes: Option<ISO14823Attributes>,
1443 ) -> Self {
1444 Self {
1445 owner,
1446 version,
1447 pictogram_code,
1448 value,
1449 unit,
1450 attributes,
1451 }
1452 }
1453 }
1454 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1455 #[rasn(delegate, size("1..=16", extensible))]
1456 pub struct AutomatedVehicleContainer(pub SequenceOf<AvcPart>);
1457 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1458 #[rasn(automatic_tags)]
1459 #[non_exhaustive]
1460 pub struct AutomatedVehicleRule {
1461 pub priority: PriorityLevel,
1462 #[rasn(identifier = "allowedSaeAutomationLevels")]
1463 pub allowed_sae_automation_levels: SaeAutomationLevels,
1464 #[rasn(identifier = "minGapBetweenVehicles")]
1465 pub min_gap_between_vehicles: Option<GapBetweenVehicles>,
1466 #[rasn(identifier = "recGapBetweenVehicles")]
1467 pub rec_gap_between_vehicles: Option<GapBetweenVehicles>,
1468 #[rasn(identifier = "automatedVehicleMaxSpeedLimit")]
1469 pub automated_vehicle_max_speed_limit: Option<SpeedValue>,
1470 #[rasn(identifier = "automatedVehicleMinSpeedLimit")]
1471 pub automated_vehicle_min_speed_limit: Option<SpeedValue>,
1472 #[rasn(identifier = "automatedVehicleSpeedRecommendation")]
1473 pub automated_vehicle_speed_recommendation: Option<SpeedValue>,
1474 #[rasn(identifier = "roadSignCodes")]
1475 pub road_sign_codes: Option<RoadSignCodes>,
1476 #[rasn(identifier = "extraText")]
1477 pub extra_text: Option<ConstraintTextLines2>,
1478 }
1479 impl AutomatedVehicleRule {
1480 pub fn new(
1481 priority: PriorityLevel,
1482 allowed_sae_automation_levels: SaeAutomationLevels,
1483 min_gap_between_vehicles: Option<GapBetweenVehicles>,
1484 rec_gap_between_vehicles: Option<GapBetweenVehicles>,
1485 automated_vehicle_max_speed_limit: Option<SpeedValue>,
1486 automated_vehicle_min_speed_limit: Option<SpeedValue>,
1487 automated_vehicle_speed_recommendation: Option<SpeedValue>,
1488 road_sign_codes: Option<RoadSignCodes>,
1489 extra_text: Option<ConstraintTextLines2>,
1490 ) -> Self {
1491 Self {
1492 priority,
1493 allowed_sae_automation_levels,
1494 min_gap_between_vehicles,
1495 rec_gap_between_vehicles,
1496 automated_vehicle_max_speed_limit,
1497 automated_vehicle_min_speed_limit,
1498 automated_vehicle_speed_recommendation,
1499 road_sign_codes,
1500 extra_text,
1501 }
1502 }
1503 }
1504 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1505 #[rasn(delegate, size("1..=5"))]
1506 pub struct AutomatedVehicleRules(pub SequenceOf<AutomatedVehicleRule>);
1507 #[doc = " new container in V2"]
1508 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1509 #[rasn(automatic_tags)]
1510 #[non_exhaustive]
1511 pub struct AvcPart {
1512 #[rasn(identifier = "detectionZoneIds")]
1513 pub detection_zone_ids: Option<ZoneIds>,
1514 #[rasn(identifier = "relevanceZoneIds")]
1515 pub relevance_zone_ids: ZoneIds,
1516 pub direction: Option<Direction>,
1517 #[rasn(identifier = "applicableLanes")]
1518 pub applicable_lanes: Option<LanePositions>,
1519 #[rasn(identifier = "vehicleCharacteristics")]
1520 pub vehicle_characteristics: Option<VehicleCharacteristicsList>,
1521 #[rasn(identifier = "automatedVehicleRules")]
1522 pub automated_vehicle_rules: Option<AutomatedVehicleRules>,
1523 #[rasn(identifier = "platooningRules")]
1524 pub platooning_rules: Option<PlatooningRules>,
1525 }
1526 impl AvcPart {
1527 pub fn new(
1528 detection_zone_ids: Option<ZoneIds>,
1529 relevance_zone_ids: ZoneIds,
1530 direction: Option<Direction>,
1531 applicable_lanes: Option<LanePositions>,
1532 vehicle_characteristics: Option<VehicleCharacteristicsList>,
1533 automated_vehicle_rules: Option<AutomatedVehicleRules>,
1534 platooning_rules: Option<PlatooningRules>,
1535 ) -> Self {
1536 Self {
1537 detection_zone_ids,
1538 relevance_zone_ids,
1539 direction,
1540 applicable_lanes,
1541 vehicle_characteristics,
1542 automated_vehicle_rules,
1543 platooning_rules,
1544 }
1545 }
1546 }
1547 #[doc = " Defition of IVI specific data elements "]
1548 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1549 #[rasn(delegate, value("-20..=21"))]
1550 pub struct BankingAngle(pub i8);
1551 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1552 #[rasn(delegate, value("0..=3"))]
1553 pub struct ComparisonOperator(pub u8);
1554 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1555 #[rasn(automatic_tags)]
1556 pub struct CompleteVehicleCharacteristics {
1557 pub tractor: Option<TractorCharacteristics>,
1558 pub trailer: Option<TrailerCharacteristicsList>,
1559 pub train: Option<TrainCharacteristics>,
1560 }
1561 impl CompleteVehicleCharacteristics {
1562 pub fn new(
1563 tractor: Option<TractorCharacteristics>,
1564 trailer: Option<TrailerCharacteristicsList>,
1565 train: Option<TrainCharacteristics>,
1566 ) -> Self {
1567 Self {
1568 tractor,
1569 trailer,
1570 train,
1571 }
1572 }
1573 }
1574 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1575 #[rasn(automatic_tags)]
1576 pub struct ComputedSegment {
1577 #[rasn(identifier = "zoneId")]
1578 pub zone_id: Zid,
1579 #[rasn(identifier = "laneNumber")]
1580 pub lane_number: LanePosition,
1581 #[rasn(identifier = "laneWidth")]
1582 pub lane_width: IviLaneWidth,
1583 #[rasn(value("-32768..=32767"), identifier = "offsetDistance")]
1584 pub offset_distance: Option<i16>,
1585 #[rasn(identifier = "offsetPosition")]
1586 pub offset_position: Option<DeltaReferencePosition>,
1587 }
1588 impl ComputedSegment {
1589 pub fn new(
1590 zone_id: Zid,
1591 lane_number: LanePosition,
1592 lane_width: IviLaneWidth,
1593 offset_distance: Option<i16>,
1594 offset_position: Option<DeltaReferencePosition>,
1595 ) -> Self {
1596 Self {
1597 zone_id,
1598 lane_number,
1599 lane_width,
1600 offset_distance,
1601 offset_position,
1602 }
1603 }
1604 }
1605 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1606 #[rasn(delegate, value("0..=15", extensible))]
1607 pub struct Condition(pub Integer);
1608 #[doc = " new DF in V2"]
1609 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1610 #[rasn(delegate, size("1..=8", extensible))]
1611 pub struct ConnectedDenms(pub SequenceOf<ActionID>);
1612 #[doc = "size extension in V2"]
1613 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1614 #[rasn(delegate, size("1..=4", extensible))]
1615 pub struct ConstraintTextLines1(pub SequenceOf<Text>);
1616 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1617 #[rasn(delegate, size("1..=4", extensible))]
1618 pub struct ConstraintTextLines2(pub SequenceOf<Text>);
1619 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1620 #[rasn(delegate, value("0..=7", extensible))]
1621 pub struct DefinitionAccuracy(pub Integer);
1622 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1623 #[rasn(automatic_tags)]
1624 pub struct DeltaPosition {
1625 #[rasn(identifier = "deltaLatitude")]
1626 pub delta_latitude: DeltaLatitude,
1627 #[rasn(identifier = "deltaLongitude")]
1628 pub delta_longitude: DeltaLongitude,
1629 }
1630 impl DeltaPosition {
1631 pub fn new(delta_latitude: DeltaLatitude, delta_longitude: DeltaLongitude) -> Self {
1632 Self {
1633 delta_latitude,
1634 delta_longitude,
1635 }
1636 }
1637 }
1638 #[doc = " new DF in V2"]
1639 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1640 #[rasn(delegate, size("1..=32", extensible))]
1641 pub struct DeltaPositions(pub SequenceOf<DeltaPosition>);
1642 #[doc = "size extension in V2"]
1643 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1644 #[rasn(delegate, size("1..=32", extensible))]
1645 pub struct DeltaReferencePositions(pub SequenceOf<DeltaReferencePosition>);
1646 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1647 #[rasn(delegate, value("0..=255"))]
1648 pub struct Depth(pub u8);
1649 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1650 #[rasn(delegate, value("0..=3"))]
1651 pub struct Direction(pub u8);
1652 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1653 #[rasn(delegate, value("0..=3"))]
1654 pub struct DriverCharacteristics(pub u8);
1655 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1656 #[rasn(delegate, value("0..=101"))]
1657 pub struct FrictionCoefficient(pub u8);
1658 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1659 #[rasn(delegate, value("0..=255"))]
1660 pub struct GapBetweenVehicles(pub u8);
1661 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1662 #[rasn(delegate, size("1..=16", extensible))]
1663 pub struct GeneralIviContainer(pub SequenceOf<GicPart>);
1664 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1665 #[rasn(automatic_tags)]
1666 #[non_exhaustive]
1667 pub struct GeographicLocationContainer {
1668 #[rasn(identifier = "referencePosition")]
1669 pub reference_position: ReferencePosition,
1670 #[rasn(identifier = "referencePositionTime")]
1671 pub reference_position_time: Option<TimestampIts>,
1672 #[rasn(identifier = "referencePositionHeading")]
1673 pub reference_position_heading: Option<Heading>,
1674 #[rasn(identifier = "referencePositionSpeed")]
1675 pub reference_position_speed: Option<Speed>,
1676 pub parts: GlcParts,
1677 }
1678 impl GeographicLocationContainer {
1679 pub fn new(
1680 reference_position: ReferencePosition,
1681 reference_position_time: Option<TimestampIts>,
1682 reference_position_heading: Option<Heading>,
1683 reference_position_speed: Option<Speed>,
1684 parts: GlcParts,
1685 ) -> Self {
1686 Self {
1687 reference_position,
1688 reference_position_time,
1689 reference_position_heading,
1690 reference_position_speed,
1691 parts,
1692 }
1693 }
1694 }
1695 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1696 #[rasn(automatic_tags)]
1697 #[non_exhaustive]
1698 pub struct GicPart {
1699 #[rasn(identifier = "detectionZoneIds")]
1700 pub detection_zone_ids: Option<ZoneIds>,
1701 #[rasn(identifier = "its-Rrid")]
1702 pub its_rrid: Option<VarLengthNumber>,
1703 #[rasn(identifier = "relevanceZoneIds")]
1704 pub relevance_zone_ids: Option<ZoneIds>,
1705 pub direction: Option<Direction>,
1706 #[rasn(identifier = "driverAwarenessZoneIds")]
1707 pub driver_awareness_zone_ids: Option<ZoneIds>,
1708 #[rasn(value("0..=255"), identifier = "minimumAwarenessTime")]
1709 pub minimum_awareness_time: Option<u8>,
1710 #[rasn(identifier = "applicableLanes")]
1711 pub applicable_lanes: Option<LanePositions>,
1712 #[rasn(identifier = "iviType")]
1713 pub ivi_type: IviType,
1714 #[rasn(identifier = "iviPurpose")]
1715 pub ivi_purpose: Option<IviPurpose>,
1716 #[rasn(identifier = "laneStatus")]
1717 pub lane_status: Option<LaneStatus>,
1718 #[rasn(identifier = "vehicleCharacteristics")]
1719 pub vehicle_characteristics: Option<VehicleCharacteristicsList>,
1720 #[rasn(identifier = "driverCharacteristics")]
1721 pub driver_characteristics: Option<DriverCharacteristics>,
1722 #[rasn(value("1..=4", extensible), identifier = "layoutId")]
1723 pub layout_id: Option<Integer>,
1724 #[rasn(value("1..=64", extensible), identifier = "preStoredlayoutId")]
1725 pub pre_storedlayout_id: Option<Integer>,
1726 #[rasn(identifier = "roadSignCodes")]
1727 pub road_sign_codes: RoadSignCodes,
1728 #[rasn(identifier = "extraText")]
1729 pub extra_text: Option<ConstraintTextLines1>,
1730 }
1731 impl GicPart {
1732 pub fn new(
1733 detection_zone_ids: Option<ZoneIds>,
1734 its_rrid: Option<VarLengthNumber>,
1735 relevance_zone_ids: Option<ZoneIds>,
1736 direction: Option<Direction>,
1737 driver_awareness_zone_ids: Option<ZoneIds>,
1738 minimum_awareness_time: Option<u8>,
1739 applicable_lanes: Option<LanePositions>,
1740 ivi_type: IviType,
1741 ivi_purpose: Option<IviPurpose>,
1742 lane_status: Option<LaneStatus>,
1743 vehicle_characteristics: Option<VehicleCharacteristicsList>,
1744 driver_characteristics: Option<DriverCharacteristics>,
1745 layout_id: Option<Integer>,
1746 pre_storedlayout_id: Option<Integer>,
1747 road_sign_codes: RoadSignCodes,
1748 extra_text: Option<ConstraintTextLines1>,
1749 ) -> Self {
1750 Self {
1751 detection_zone_ids,
1752 its_rrid,
1753 relevance_zone_ids,
1754 direction,
1755 driver_awareness_zone_ids,
1756 minimum_awareness_time,
1757 applicable_lanes,
1758 ivi_type,
1759 ivi_purpose,
1760 lane_status,
1761 vehicle_characteristics,
1762 driver_characteristics,
1763 layout_id,
1764 pre_storedlayout_id,
1765 road_sign_codes,
1766 extra_text,
1767 }
1768 }
1769 }
1770 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1771 #[rasn(automatic_tags)]
1772 #[non_exhaustive]
1773 pub struct GlcPart {
1774 #[rasn(identifier = "zoneId")]
1775 pub zone_id: Zid,
1776 #[rasn(identifier = "laneNumber")]
1777 pub lane_number: Option<LanePosition>,
1778 #[rasn(value("0..=255"), identifier = "zoneExtension")]
1779 pub zone_extension: Option<u8>,
1780 #[rasn(identifier = "zoneHeading")]
1781 pub zone_heading: Option<HeadingValue>,
1782 pub zone: Option<Zone>,
1783 }
1784 impl GlcPart {
1785 pub fn new(
1786 zone_id: Zid,
1787 lane_number: Option<LanePosition>,
1788 zone_extension: Option<u8>,
1789 zone_heading: Option<HeadingValue>,
1790 zone: Option<Zone>,
1791 ) -> Self {
1792 Self {
1793 zone_id,
1794 lane_number,
1795 zone_extension,
1796 zone_heading,
1797 zone,
1798 }
1799 }
1800 }
1801 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1802 #[rasn(delegate, size("1..=16", extensible))]
1803 pub struct GlcParts(pub SequenceOf<GlcPart>);
1804 #[doc = " new DE in V2"]
1805 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1806 #[rasn(delegate, value("0..=15", extensible))]
1807 pub struct GoodsType(pub Integer);
1808 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1809 #[rasn(choice, automatic_tags)]
1810 pub enum ISO14823Attribute {
1811 dtm(InternationalSignApplicablePeriod),
1812 edt(InternationalSignExemptedApplicablePeriod),
1813 dfl(InternationalSignDirectionalFlowOfLane),
1814 ved(InternationalSignApplicableVehicleDimensions),
1815 spe(InternationalSignSpeedLimits),
1816 roi(InternationalSignRateOfIncline),
1817 dbv(InternationalSignDistanceBetweenVehicles),
1818 ddd(InternationalSignDestinationInformation),
1819 }
1820 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1821 #[rasn(delegate, size("1..=8", extensible))]
1822 pub struct ISO14823Attributes(pub SequenceOf<ISO14823Attribute>);
1823 #[doc = " Inner type "]
1824 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
1825 #[rasn(enumerated)]
1826 #[non_exhaustive]
1827 pub enum ISO14823CodePictogramCodeServiceCategoryCodeTrafficSignPictogram {
1828 dangerWarning = 0,
1829 regulatory = 1,
1830 informative = 2,
1831 }
1832 #[doc = " Inner type "]
1833 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
1834 #[rasn(enumerated)]
1835 #[non_exhaustive]
1836 pub enum ISO14823CodePictogramCodeServiceCategoryCodePublicFacilitiesPictogram {
1837 publicFacilities = 0,
1838 }
1839 #[doc = " Inner type "]
1840 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
1841 #[rasn(enumerated)]
1842 #[non_exhaustive]
1843 pub enum ISO14823CodePictogramCodeServiceCategoryCodeAmbientOrRoadConditionPictogram {
1844 ambientCondition = 0,
1845 roadCondition = 1,
1846 }
1847 #[doc = " Inner type "]
1848 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1849 #[rasn(choice, automatic_tags)]
1850 #[non_exhaustive]
1851 pub enum ISO14823CodePictogramCodeServiceCategoryCode {
1852 trafficSignPictogram(ISO14823CodePictogramCodeServiceCategoryCodeTrafficSignPictogram),
1853 publicFacilitiesPictogram(
1854 ISO14823CodePictogramCodeServiceCategoryCodePublicFacilitiesPictogram,
1855 ),
1856 ambientOrRoadConditionPictogram(
1857 ISO14823CodePictogramCodeServiceCategoryCodeAmbientOrRoadConditionPictogram,
1858 ),
1859 }
1860 #[doc = " Inner type "]
1861 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1862 #[rasn(automatic_tags)]
1863 pub struct ISO14823CodePictogramCodePictogramCategoryCode {
1864 #[rasn(value("1..=9"))]
1865 pub nature: u8,
1866 #[rasn(value("0..=99"), identifier = "serialNumber")]
1867 pub serial_number: u8,
1868 }
1869 impl ISO14823CodePictogramCodePictogramCategoryCode {
1870 pub fn new(nature: u8, serial_number: u8) -> Self {
1871 Self {
1872 nature,
1873 serial_number,
1874 }
1875 }
1876 }
1877 #[doc = " Inner type "]
1878 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1879 #[rasn(automatic_tags)]
1880 pub struct ISO14823CodePictogramCode {
1881 #[rasn(size("2"), identifier = "countryCode")]
1882 pub country_code: Option<OctetString>,
1883 #[rasn(identifier = "serviceCategoryCode")]
1884 pub service_category_code: ISO14823CodePictogramCodeServiceCategoryCode,
1885 #[rasn(identifier = "pictogramCategoryCode")]
1886 pub pictogram_category_code: ISO14823CodePictogramCodePictogramCategoryCode,
1887 }
1888 impl ISO14823CodePictogramCode {
1889 pub fn new(
1890 country_code: Option<OctetString>,
1891 service_category_code: ISO14823CodePictogramCodeServiceCategoryCode,
1892 pictogram_category_code: ISO14823CodePictogramCodePictogramCategoryCode,
1893 ) -> Self {
1894 Self {
1895 country_code,
1896 service_category_code,
1897 pictogram_category_code,
1898 }
1899 }
1900 }
1901 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1902 #[rasn(automatic_tags)]
1903 pub struct ISO14823Code {
1904 #[rasn(identifier = "pictogramCode")]
1905 pub pictogram_code: ISO14823CodePictogramCode,
1906 pub attributes: Option<ISO14823Attributes>,
1907 }
1908 impl ISO14823Code {
1909 pub fn new(
1910 pictogram_code: ISO14823CodePictogramCode,
1911 attributes: Option<ISO14823Attributes>,
1912 ) -> Self {
1913 Self {
1914 pictogram_code,
1915 attributes,
1916 }
1917 }
1918 }
1919 #[doc = "Definition of Containers"]
1920 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1921 #[rasn(choice, automatic_tags)]
1922 #[non_exhaustive]
1923 pub enum IviContainer {
1924 glc(GeographicLocationContainer),
1925 giv(GeneralIviContainer),
1926 rcc(RoadConfigurationContainer),
1927 tc(TextContainer),
1928 lac(LayoutContainer),
1929 #[rasn(extension_addition)]
1930 avc(AutomatedVehicleContainer),
1931 #[rasn(extension_addition)]
1932 mlc(MapLocationContainer),
1933 #[rasn(extension_addition)]
1934 rsc(RoadSurfaceContainer),
1935 }
1936 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1937 #[rasn(delegate, size("1..=8", extensible))]
1938 pub struct IviContainers(pub SequenceOf<IviContainer>);
1939 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1940 #[rasn(delegate, value("1..=32767", extensible))]
1941 pub struct IviIdentificationNumber(pub Integer);
1942 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1943 #[rasn(delegate, size("1..=8"))]
1944 pub struct IviIdentificationNumbers(pub SequenceOf<IviIdentificationNumber>);
1945 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1946 #[rasn(delegate, value("0..=1023"))]
1947 pub struct IviLaneWidth(pub u16);
1948 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1949 #[rasn(automatic_tags)]
1950 #[non_exhaustive]
1951 pub struct IviManagementContainer {
1952 #[rasn(identifier = "serviceProviderId")]
1953 pub service_provider_id: Provider,
1954 #[rasn(identifier = "iviIdentificationNumber")]
1955 pub ivi_identification_number: IviIdentificationNumber,
1956 #[rasn(identifier = "timeStamp")]
1957 pub time_stamp: Option<TimestampIts>,
1958 #[rasn(identifier = "validFrom")]
1959 pub valid_from: Option<TimestampIts>,
1960 #[rasn(identifier = "validTo")]
1961 pub valid_to: Option<TimestampIts>,
1962 #[rasn(identifier = "connectedIviStructures")]
1963 pub connected_ivi_structures: Option<IviIdentificationNumbers>,
1964 #[rasn(identifier = "iviStatus")]
1965 pub ivi_status: IviStatus,
1966 #[rasn(extension_addition, identifier = "connectedDenms")]
1967 pub connected_denms: Option<ConnectedDenms>,
1968 }
1969 impl IviManagementContainer {
1970 pub fn new(
1971 service_provider_id: Provider,
1972 ivi_identification_number: IviIdentificationNumber,
1973 time_stamp: Option<TimestampIts>,
1974 valid_from: Option<TimestampIts>,
1975 valid_to: Option<TimestampIts>,
1976 connected_ivi_structures: Option<IviIdentificationNumbers>,
1977 ivi_status: IviStatus,
1978 connected_denms: Option<ConnectedDenms>,
1979 ) -> Self {
1980 Self {
1981 service_provider_id,
1982 ivi_identification_number,
1983 time_stamp,
1984 valid_from,
1985 valid_to,
1986 connected_ivi_structures,
1987 ivi_status,
1988 connected_denms,
1989 }
1990 }
1991 }
1992 #[doc = " only renamed from V1, no change"]
1993 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1994 #[rasn(delegate, value("0..=3"))]
1995 pub struct IviPurpose(pub u8);
1996 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1997 #[rasn(delegate, value("0..=7"))]
1998 pub struct IviStatus(pub u8);
1999 #[doc = " Definition of IVI structure"]
2000 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2001 #[rasn(automatic_tags)]
2002 pub struct IviStructure {
2003 pub mandatory: IviManagementContainer,
2004 pub optional: Option<IviContainers>,
2005 }
2006 impl IviStructure {
2007 pub fn new(mandatory: IviManagementContainer, optional: Option<IviContainers>) -> Self {
2008 Self {
2009 mandatory,
2010 optional,
2011 }
2012 }
2013 }
2014 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2015 #[rasn(delegate, value("0..=7"))]
2016 pub struct IviType(pub u8);
2017 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2018 #[rasn(automatic_tags)]
2019 pub struct LaneCharacteristics {
2020 #[rasn(identifier = "zoneDefinitionAccuracy")]
2021 pub zone_definition_accuracy: DefinitionAccuracy,
2022 #[rasn(identifier = "existinglaneMarkingStatus")]
2023 pub existinglane_marking_status: LaneMarkingStatus,
2024 #[rasn(identifier = "newlaneMarkingColour")]
2025 pub newlane_marking_colour: MarkingColour,
2026 #[rasn(identifier = "laneDelimitationLeft")]
2027 pub lane_delimitation_left: LaneDelimitation,
2028 #[rasn(identifier = "laneDelimitationRight")]
2029 pub lane_delimitation_right: LaneDelimitation,
2030 #[rasn(identifier = "mergingWith")]
2031 pub merging_with: Zid,
2032 }
2033 impl LaneCharacteristics {
2034 pub fn new(
2035 zone_definition_accuracy: DefinitionAccuracy,
2036 existinglane_marking_status: LaneMarkingStatus,
2037 newlane_marking_colour: MarkingColour,
2038 lane_delimitation_left: LaneDelimitation,
2039 lane_delimitation_right: LaneDelimitation,
2040 merging_with: Zid,
2041 ) -> Self {
2042 Self {
2043 zone_definition_accuracy,
2044 existinglane_marking_status,
2045 newlane_marking_colour,
2046 lane_delimitation_left,
2047 lane_delimitation_right,
2048 merging_with,
2049 }
2050 }
2051 }
2052 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2053 #[rasn(delegate, size("1..=16", extensible))]
2054 pub struct LaneConfiguration(pub SequenceOf<LaneInformation>);
2055 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2056 #[rasn(delegate, value("0..=7", extensible))]
2057 pub struct LaneDelimitation(pub Integer);
2058 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2059 #[rasn(delegate, size("1..=16", extensible))]
2060 pub struct LaneIds(pub SequenceOf<LaneID>);
2061 #[doc = " Inner type "]
2062 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2063 #[rasn(automatic_tags)]
2064 pub struct LaneInformationExtGroupDetectionZoneIds {
2065 #[rasn(identifier = "detectionZoneIds")]
2066 pub detection_zone_ids: Option<ZoneIds>,
2067 #[rasn(identifier = "relevanceZoneIds")]
2068 pub relevance_zone_ids: Option<ZoneIds>,
2069 #[rasn(identifier = "laneCharacteristics")]
2070 pub lane_characteristics: Option<LaneCharacteristics>,
2071 #[rasn(identifier = "laneSurfaceStaticCharacteristics")]
2072 pub lane_surface_static_characteristics: Option<RoadSurfaceStaticCharacteristics>,
2073 #[rasn(identifier = "laneSurfaceDynamicCharacteristics")]
2074 pub lane_surface_dynamic_characteristics: Option<RoadSurfaceDynamicCharacteristics>,
2075 }
2076 impl LaneInformationExtGroupDetectionZoneIds {
2077 pub fn new(
2078 detection_zone_ids: Option<ZoneIds>,
2079 relevance_zone_ids: Option<ZoneIds>,
2080 lane_characteristics: Option<LaneCharacteristics>,
2081 lane_surface_static_characteristics: Option<RoadSurfaceStaticCharacteristics>,
2082 lane_surface_dynamic_characteristics: Option<RoadSurfaceDynamicCharacteristics>,
2083 ) -> Self {
2084 Self {
2085 detection_zone_ids,
2086 relevance_zone_ids,
2087 lane_characteristics,
2088 lane_surface_static_characteristics,
2089 lane_surface_dynamic_characteristics,
2090 }
2091 }
2092 }
2093 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2094 #[rasn(automatic_tags)]
2095 #[non_exhaustive]
2096 pub struct LaneInformation {
2097 #[rasn(identifier = "laneNumber")]
2098 pub lane_number: LanePosition,
2099 pub direction: Direction,
2100 pub validity: Option<InternationalSignApplicablePeriod>,
2101 #[rasn(identifier = "laneType")]
2102 pub lane_type: LaneType,
2103 #[rasn(identifier = "laneTypeQualifier")]
2104 pub lane_type_qualifier: Option<CompleteVehicleCharacteristics>,
2105 #[rasn(identifier = "laneStatus")]
2106 pub lane_status: LaneStatus,
2107 #[rasn(identifier = "laneWidth")]
2108 pub lane_width: Option<IviLaneWidth>,
2109 #[rasn(extension_addition_group, identifier = "SEQUENCE")]
2110 pub ext_group_detection_zone_ids: Option<LaneInformationExtGroupDetectionZoneIds>,
2111 }
2112 impl LaneInformation {
2113 pub fn new(
2114 lane_number: LanePosition,
2115 direction: Direction,
2116 validity: Option<InternationalSignApplicablePeriod>,
2117 lane_type: LaneType,
2118 lane_type_qualifier: Option<CompleteVehicleCharacteristics>,
2119 lane_status: LaneStatus,
2120 lane_width: Option<IviLaneWidth>,
2121 ext_group_detection_zone_ids: Option<LaneInformationExtGroupDetectionZoneIds>,
2122 ) -> Self {
2123 Self {
2124 lane_number,
2125 direction,
2126 validity,
2127 lane_type,
2128 lane_type_qualifier,
2129 lane_status,
2130 lane_width,
2131 ext_group_detection_zone_ids,
2132 }
2133 }
2134 }
2135 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
2136 #[rasn(delegate)]
2137 pub struct LaneMarkingStatus(pub bool);
2138 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2139 #[rasn(delegate, size("1..=8", extensible))]
2140 pub struct LanePositions(pub SequenceOf<LanePosition>);
2141 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2142 #[rasn(delegate, value("0..=7", extensible))]
2143 pub struct LaneStatus(pub Integer);
2144 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2145 #[rasn(delegate, value("0..=31"))]
2146 pub struct LaneType(pub u8);
2147 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2148 #[rasn(automatic_tags)]
2149 pub struct LayoutComponent {
2150 #[rasn(value("1..=8", extensible), identifier = "layoutComponentId")]
2151 pub layout_component_id: Integer,
2152 #[rasn(value("10..=73"))]
2153 pub height: u8,
2154 #[rasn(value("10..=265"))]
2155 pub width: u16,
2156 #[rasn(value("10..=265"))]
2157 pub x: u16,
2158 #[rasn(value("10..=73"))]
2159 pub y: u8,
2160 #[rasn(value("0..=1"), identifier = "textScripting")]
2161 pub text_scripting: u8,
2162 }
2163 impl LayoutComponent {
2164 pub fn new(
2165 layout_component_id: Integer,
2166 height: u8,
2167 width: u16,
2168 x: u16,
2169 y: u8,
2170 text_scripting: u8,
2171 ) -> Self {
2172 Self {
2173 layout_component_id,
2174 height,
2175 width,
2176 x,
2177 y,
2178 text_scripting,
2179 }
2180 }
2181 }
2182 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2183 #[rasn(delegate, size("1..=4", extensible))]
2184 pub struct LayoutComponents(pub SequenceOf<LayoutComponent>);
2185 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2186 #[rasn(automatic_tags)]
2187 #[non_exhaustive]
2188 pub struct LayoutContainer {
2189 #[rasn(value("1..=4", extensible), identifier = "layoutId")]
2190 pub layout_id: Integer,
2191 #[rasn(value("10..=73"))]
2192 pub height: Option<u8>,
2193 #[rasn(value("10..=265"))]
2194 pub width: Option<u16>,
2195 #[rasn(identifier = "layoutComponents")]
2196 pub layout_components: LayoutComponents,
2197 }
2198 impl LayoutContainer {
2199 pub fn new(
2200 layout_id: Integer,
2201 height: Option<u8>,
2202 width: Option<u16>,
2203 layout_components: LayoutComponents,
2204 ) -> Self {
2205 Self {
2206 layout_id,
2207 height,
2208 width,
2209 layout_components,
2210 }
2211 }
2212 }
2213 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2214 #[rasn(automatic_tags)]
2215 pub struct LoadType {
2216 #[rasn(identifier = "goodsType")]
2217 pub goods_type: GoodsType,
2218 #[rasn(identifier = "dangerousGoodsType")]
2219 pub dangerous_goods_type: DangerousGoodsBasic,
2220 #[rasn(identifier = "specialTransportType")]
2221 pub special_transport_type: SpecialTransportType,
2222 }
2223 impl LoadType {
2224 pub fn new(
2225 goods_type: GoodsType,
2226 dangerous_goods_type: DangerousGoodsBasic,
2227 special_transport_type: SpecialTransportType,
2228 ) -> Self {
2229 Self {
2230 goods_type,
2231 dangerous_goods_type,
2232 special_transport_type,
2233 }
2234 }
2235 }
2236 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2237 #[rasn(automatic_tags)]
2238 pub struct MapLocationContainer {
2239 pub reference: MapReference,
2240 pub parts: MlcParts,
2241 }
2242 impl MapLocationContainer {
2243 pub fn new(reference: MapReference, parts: MlcParts) -> Self {
2244 Self { reference, parts }
2245 }
2246 }
2247 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2248 #[rasn(choice, automatic_tags)]
2249 pub enum MapReference {
2250 roadsegment(RoadSegmentReferenceID),
2251 intersection(IntersectionReferenceID),
2252 }
2253 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2254 #[rasn(delegate, value("0..=7", extensible))]
2255 pub struct MarkingColour(pub Integer);
2256 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2257 #[rasn(delegate, value("0..=7", extensible))]
2258 pub struct MaterialType(pub Integer);
2259 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2260 #[rasn(delegate, value("1..=64"))]
2261 pub struct MaxLenghtOfPlatoon(pub u8);
2262 #[doc = " new DE in V2"]
2263 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2264 #[rasn(delegate, value("2..=64"))]
2265 pub struct MaxNoOfVehicles(pub u8);
2266 #[doc = " new container part in V2"]
2267 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2268 #[rasn(automatic_tags)]
2269 pub struct MlcPart {
2270 #[rasn(identifier = "zoneId")]
2271 pub zone_id: Zid,
2272 #[rasn(identifier = "laneIds")]
2273 pub lane_ids: Option<LaneIds>,
2274 }
2275 impl MlcPart {
2276 pub fn new(zone_id: Zid, lane_ids: Option<LaneIds>) -> Self {
2277 Self { zone_id, lane_ids }
2278 }
2279 }
2280 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2281 #[rasn(delegate, size("1..=16", extensible))]
2282 pub struct MlcParts(pub SequenceOf<MlcPart>);
2283 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2284 #[rasn(automatic_tags)]
2285 #[non_exhaustive]
2286 pub struct PlatooningRule {
2287 pub priority: PriorityLevel,
2288 #[rasn(identifier = "allowedSaeAutomationLevels")]
2289 pub allowed_sae_automation_levels: SaeAutomationLevels,
2290 #[rasn(identifier = "maxNoOfVehicles")]
2291 pub max_no_of_vehicles: Option<MaxNoOfVehicles>,
2292 #[rasn(identifier = "maxLenghtOfPlatoon")]
2293 pub max_lenght_of_platoon: Option<MaxLenghtOfPlatoon>,
2294 #[rasn(identifier = "minGapBetweenVehicles")]
2295 pub min_gap_between_vehicles: Option<GapBetweenVehicles>,
2296 #[rasn(identifier = "platoonMaxSpeedLimit")]
2297 pub platoon_max_speed_limit: Option<SpeedValue>,
2298 #[rasn(identifier = "platoonMinSpeedLimit")]
2299 pub platoon_min_speed_limit: Option<SpeedValue>,
2300 #[rasn(identifier = "platoonSpeedRecommendation")]
2301 pub platoon_speed_recommendation: Option<SpeedValue>,
2302 #[rasn(identifier = "roadSignCodes")]
2303 pub road_sign_codes: Option<RoadSignCodes>,
2304 #[rasn(identifier = "extraText")]
2305 pub extra_text: Option<ConstraintTextLines2>,
2306 }
2307 impl PlatooningRule {
2308 pub fn new(
2309 priority: PriorityLevel,
2310 allowed_sae_automation_levels: SaeAutomationLevels,
2311 max_no_of_vehicles: Option<MaxNoOfVehicles>,
2312 max_lenght_of_platoon: Option<MaxLenghtOfPlatoon>,
2313 min_gap_between_vehicles: Option<GapBetweenVehicles>,
2314 platoon_max_speed_limit: Option<SpeedValue>,
2315 platoon_min_speed_limit: Option<SpeedValue>,
2316 platoon_speed_recommendation: Option<SpeedValue>,
2317 road_sign_codes: Option<RoadSignCodes>,
2318 extra_text: Option<ConstraintTextLines2>,
2319 ) -> Self {
2320 Self {
2321 priority,
2322 allowed_sae_automation_levels,
2323 max_no_of_vehicles,
2324 max_lenght_of_platoon,
2325 min_gap_between_vehicles,
2326 platoon_max_speed_limit,
2327 platoon_min_speed_limit,
2328 platoon_speed_recommendation,
2329 road_sign_codes,
2330 extra_text,
2331 }
2332 }
2333 }
2334 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2335 #[rasn(delegate, size("1..=5"))]
2336 pub struct PlatooningRules(pub SequenceOf<PlatooningRule>);
2337 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2338 #[rasn(choice, automatic_tags)]
2339 #[non_exhaustive]
2340 pub enum PolygonalLine {
2341 deltaPositions(DeltaPositions),
2342 deltaPositionsWithAltitude(DeltaReferencePositions),
2343 absolutePositions(AbsolutePositions),
2344 absolutePositionsWithAltitude(AbsolutePositionsWAltitude),
2345 }
2346 #[doc = " new DE in V2"]
2347 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2348 #[rasn(delegate, value("0..=2"))]
2349 pub struct PriorityLevel(pub u8);
2350 #[doc = " new DE in V2"]
2351 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2352 #[rasn(delegate, value("0..=15"))]
2353 pub struct RSCUnit(pub u8);
2354 #[doc = " Inner type "]
2355 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2356 #[rasn(choice, automatic_tags)]
2357 #[non_exhaustive]
2358 pub enum RSCodeCode {
2359 viennaConvention(VcCode),
2360 iso14823(ISO14823Code),
2361 #[rasn(value("0..=65535"))]
2362 itisCodes(u16),
2363 anyCatalogue(AnyCatalogue),
2364 }
2365 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2366 #[rasn(automatic_tags)]
2367 pub struct RSCode {
2368 #[rasn(value("1..=4", extensible), identifier = "layoutComponentId")]
2369 pub layout_component_id: Option<Integer>,
2370 pub code: RSCodeCode,
2371 }
2372 impl RSCode {
2373 pub fn new(layout_component_id: Option<Integer>, code: RSCodeCode) -> Self {
2374 Self {
2375 layout_component_id,
2376 code,
2377 }
2378 }
2379 }
2380 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2381 #[rasn(automatic_tags)]
2382 #[non_exhaustive]
2383 pub struct RccPart {
2384 #[rasn(identifier = "relevanceZoneIds")]
2385 pub relevance_zone_ids: ZoneIds,
2386 #[rasn(identifier = "roadType")]
2387 pub road_type: RoadType,
2388 #[rasn(identifier = "laneConfiguration")]
2389 pub lane_configuration: LaneConfiguration,
2390 }
2391 impl RccPart {
2392 pub fn new(
2393 relevance_zone_ids: ZoneIds,
2394 road_type: RoadType,
2395 lane_configuration: LaneConfiguration,
2396 ) -> Self {
2397 Self {
2398 relevance_zone_ids,
2399 road_type,
2400 lane_configuration,
2401 }
2402 }
2403 }
2404 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2405 #[rasn(delegate, size("1..=16", extensible))]
2406 pub struct RoadConfigurationContainer(pub SequenceOf<RccPart>);
2407 #[doc = " new DF in V2"]
2408 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2409 #[rasn(delegate, size("1..=4", extensible))]
2410 pub struct RoadSignCodes(pub SequenceOf<RSCode>);
2411 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2412 #[rasn(delegate, size("1..=16", extensible))]
2413 pub struct RoadSurfaceContainer(pub SequenceOf<RscPart>);
2414 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2415 #[rasn(automatic_tags)]
2416 pub struct RoadSurfaceDynamicCharacteristics {
2417 pub condition: Condition,
2418 pub temperature: Temperature,
2419 #[rasn(identifier = "iceOrWaterDepth")]
2420 pub ice_or_water_depth: Depth,
2421 pub treatment: TreatmentType,
2422 }
2423 impl RoadSurfaceDynamicCharacteristics {
2424 pub fn new(
2425 condition: Condition,
2426 temperature: Temperature,
2427 ice_or_water_depth: Depth,
2428 treatment: TreatmentType,
2429 ) -> Self {
2430 Self {
2431 condition,
2432 temperature,
2433 ice_or_water_depth,
2434 treatment,
2435 }
2436 }
2437 }
2438 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2439 #[rasn(automatic_tags)]
2440 pub struct RoadSurfaceStaticCharacteristics {
2441 #[rasn(identifier = "frictionCoefficient")]
2442 pub friction_coefficient: FrictionCoefficient,
2443 pub material: MaterialType,
2444 pub wear: WearLevel,
2445 #[rasn(identifier = "avBankingAngle")]
2446 pub av_banking_angle: BankingAngle,
2447 }
2448 impl RoadSurfaceStaticCharacteristics {
2449 pub fn new(
2450 friction_coefficient: FrictionCoefficient,
2451 material: MaterialType,
2452 wear: WearLevel,
2453 av_banking_angle: BankingAngle,
2454 ) -> Self {
2455 Self {
2456 friction_coefficient,
2457 material,
2458 wear,
2459 av_banking_angle,
2460 }
2461 }
2462 }
2463 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2464 #[rasn(automatic_tags)]
2465 pub struct RscPart {
2466 #[rasn(identifier = "detectionZoneIds")]
2467 pub detection_zone_ids: Option<ZoneIds>,
2468 #[rasn(identifier = "relevanceZoneIds")]
2469 pub relevance_zone_ids: ZoneIds,
2470 pub direction: Option<Direction>,
2471 #[rasn(identifier = "roadSurfaceStaticCharacteristics")]
2472 pub road_surface_static_characteristics: Option<RoadSurfaceStaticCharacteristics>,
2473 #[rasn(identifier = "roadSurfaceDynamicCharacteristics")]
2474 pub road_surface_dynamic_characteristics: Option<RoadSurfaceDynamicCharacteristics>,
2475 }
2476 impl RscPart {
2477 pub fn new(
2478 detection_zone_ids: Option<ZoneIds>,
2479 relevance_zone_ids: ZoneIds,
2480 direction: Option<Direction>,
2481 road_surface_static_characteristics: Option<RoadSurfaceStaticCharacteristics>,
2482 road_surface_dynamic_characteristics: Option<RoadSurfaceDynamicCharacteristics>,
2483 ) -> Self {
2484 Self {
2485 detection_zone_ids,
2486 relevance_zone_ids,
2487 direction,
2488 road_surface_static_characteristics,
2489 road_surface_dynamic_characteristics,
2490 }
2491 }
2492 }
2493 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2494 #[rasn(delegate, value("0..=5"))]
2495 pub struct SaeAutomationLevel(pub u8);
2496 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2497 #[rasn(delegate, size("1..=5"))]
2498 pub struct SaeAutomationLevels(pub SequenceOf<SaeAutomationLevel>);
2499 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2500 #[rasn(automatic_tags)]
2501 pub struct Segment {
2502 pub line: PolygonalLine,
2503 #[rasn(identifier = "laneWidth")]
2504 pub lane_width: Option<IviLaneWidth>,
2505 }
2506 impl Segment {
2507 pub fn new(line: PolygonalLine, lane_width: Option<IviLaneWidth>) -> Self {
2508 Self { line, lane_width }
2509 }
2510 }
2511 #[doc = " Inner type "]
2512 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2513 #[rasn(automatic_tags)]
2514 pub struct TcPartExtGroupIviType {
2515 #[rasn(identifier = "iviType")]
2516 pub ivi_type: IviType,
2517 #[rasn(identifier = "laneStatus")]
2518 pub lane_status: Option<LaneStatus>,
2519 #[rasn(identifier = "vehicleCharacteristics")]
2520 pub vehicle_characteristics: Option<VehicleCharacteristicsList>,
2521 }
2522 impl TcPartExtGroupIviType {
2523 pub fn new(
2524 ivi_type: IviType,
2525 lane_status: Option<LaneStatus>,
2526 vehicle_characteristics: Option<VehicleCharacteristicsList>,
2527 ) -> Self {
2528 Self {
2529 ivi_type,
2530 lane_status,
2531 vehicle_characteristics,
2532 }
2533 }
2534 }
2535 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2536 #[rasn(automatic_tags)]
2537 #[non_exhaustive]
2538 pub struct TcPart {
2539 #[rasn(identifier = "detectionZoneIds")]
2540 pub detection_zone_ids: Option<ZoneIds>,
2541 #[rasn(identifier = "relevanceZoneIds")]
2542 pub relevance_zone_ids: ZoneIds,
2543 pub direction: Option<Direction>,
2544 #[rasn(identifier = "driverAwarenessZoneIds")]
2545 pub driver_awareness_zone_ids: Option<ZoneIds>,
2546 #[rasn(value("0..=255"), identifier = "minimumAwarenessTime")]
2547 pub minimum_awareness_time: Option<u8>,
2548 #[rasn(identifier = "applicableLanes")]
2549 pub applicable_lanes: Option<LanePositions>,
2550 #[rasn(value("1..=4", extensible), identifier = "layoutId")]
2551 pub layout_id: Option<Integer>,
2552 #[rasn(value("1..=64", extensible), identifier = "preStoredlayoutId")]
2553 pub pre_storedlayout_id: Option<Integer>,
2554 pub text: Option<TextLines>,
2555 pub data: OctetString,
2556 #[rasn(extension_addition_group, identifier = "SEQUENCE")]
2557 pub ext_group_ivi_type: Option<TcPartExtGroupIviType>,
2558 }
2559 impl TcPart {
2560 pub fn new(
2561 detection_zone_ids: Option<ZoneIds>,
2562 relevance_zone_ids: ZoneIds,
2563 direction: Option<Direction>,
2564 driver_awareness_zone_ids: Option<ZoneIds>,
2565 minimum_awareness_time: Option<u8>,
2566 applicable_lanes: Option<LanePositions>,
2567 layout_id: Option<Integer>,
2568 pre_storedlayout_id: Option<Integer>,
2569 text: Option<TextLines>,
2570 data: OctetString,
2571 ext_group_ivi_type: Option<TcPartExtGroupIviType>,
2572 ) -> Self {
2573 Self {
2574 detection_zone_ids,
2575 relevance_zone_ids,
2576 direction,
2577 driver_awareness_zone_ids,
2578 minimum_awareness_time,
2579 applicable_lanes,
2580 layout_id,
2581 pre_storedlayout_id,
2582 text,
2583 data,
2584 ext_group_ivi_type,
2585 }
2586 }
2587 }
2588 #[doc = " new DE in V2"]
2589 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2590 #[rasn(delegate, value("-100..=151"))]
2591 pub struct Temperature(pub i16);
2592 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2593 #[rasn(automatic_tags)]
2594 pub struct Text {
2595 #[rasn(value("1..=4", extensible), identifier = "layoutComponentId")]
2596 pub layout_component_id: Option<Integer>,
2597 #[rasn(size("10"))]
2598 pub language: BitString,
2599 #[rasn(identifier = "textContent")]
2600 pub text_content: Utf8String,
2601 }
2602 impl Text {
2603 pub fn new(
2604 layout_component_id: Option<Integer>,
2605 language: BitString,
2606 text_content: Utf8String,
2607 ) -> Self {
2608 Self {
2609 layout_component_id,
2610 language,
2611 text_content,
2612 }
2613 }
2614 }
2615 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2616 #[rasn(delegate, size("1..=16", extensible))]
2617 pub struct TextContainer(pub SequenceOf<TcPart>);
2618 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2619 #[rasn(delegate, size("1..=4", extensible))]
2620 pub struct TextLines(pub SequenceOf<Text>);
2621 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2622 #[rasn(automatic_tags)]
2623 pub struct TractorCharacteristics {
2624 #[rasn(identifier = "equalTo")]
2625 pub equal_to: Option<VehicleCharacteristicsFixValuesList>,
2626 #[rasn(identifier = "notEqualTo")]
2627 pub not_equal_to: Option<VehicleCharacteristicsFixValuesList>,
2628 pub ranges: Option<VehicleCharacteristicsRangesList>,
2629 }
2630 impl TractorCharacteristics {
2631 pub fn new(
2632 equal_to: Option<VehicleCharacteristicsFixValuesList>,
2633 not_equal_to: Option<VehicleCharacteristicsFixValuesList>,
2634 ranges: Option<VehicleCharacteristicsRangesList>,
2635 ) -> Self {
2636 Self {
2637 equal_to,
2638 not_equal_to,
2639 ranges,
2640 }
2641 }
2642 }
2643 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2644 #[rasn(automatic_tags)]
2645 pub struct TrailerCharacteristics {
2646 #[rasn(identifier = "equalTo")]
2647 pub equal_to: Option<TrailerCharacteristicsFixValuesList>,
2648 #[rasn(identifier = "notEqualTo")]
2649 pub not_equal_to: Option<TrailerCharacteristicsFixValuesList>,
2650 pub ranges: Option<TrailerCharacteristicsRangesList>,
2651 }
2652 impl TrailerCharacteristics {
2653 pub fn new(
2654 equal_to: Option<TrailerCharacteristicsFixValuesList>,
2655 not_equal_to: Option<TrailerCharacteristicsFixValuesList>,
2656 ranges: Option<TrailerCharacteristicsRangesList>,
2657 ) -> Self {
2658 Self {
2659 equal_to,
2660 not_equal_to,
2661 ranges,
2662 }
2663 }
2664 }
2665 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2666 #[rasn(delegate, size("1..=4", extensible))]
2667 pub struct TrailerCharacteristicsFixValuesList(pub SequenceOf<VehicleCharacteristicsFixValues>);
2668 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2669 #[rasn(delegate, size("1..=3"))]
2670 pub struct TrailerCharacteristicsList(pub SequenceOf<TrailerCharacteristics>);
2671 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2672 #[rasn(delegate, size("1..=4", extensible))]
2673 pub struct TrailerCharacteristicsRangesList(pub SequenceOf<VehicleCharacteristicsRanges>);
2674 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2675 #[rasn(delegate)]
2676 pub struct TrainCharacteristics(pub TractorCharacteristics);
2677 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2678 #[rasn(delegate, value("0..=7"))]
2679 pub struct TreatmentType(pub u8);
2680 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2681 #[rasn(delegate, size("1..=8", extensible))]
2682 pub struct ValidityPeriods(pub SequenceOf<InternationalSignApplicablePeriod>);
2683 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2684 #[rasn(delegate, value("0..=7"))]
2685 pub struct VcClass(pub u8);
2686 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2687 #[rasn(automatic_tags)]
2688 pub struct VcCode {
2689 #[rasn(identifier = "roadSignClass")]
2690 pub road_sign_class: VcClass,
2691 #[rasn(value("1..=64"), identifier = "roadSignCode")]
2692 pub road_sign_code: u8,
2693 #[rasn(identifier = "vcOption")]
2694 pub vc_option: VcOption,
2695 pub validity: Option<ValidityPeriods>,
2696 #[rasn(value("0..=65535"))]
2697 pub value: Option<u16>,
2698 pub unit: Option<RSCUnit>,
2699 }
2700 impl VcCode {
2701 pub fn new(
2702 road_sign_class: VcClass,
2703 road_sign_code: u8,
2704 vc_option: VcOption,
2705 validity: Option<ValidityPeriods>,
2706 value: Option<u16>,
2707 unit: Option<RSCUnit>,
2708 ) -> Self {
2709 Self {
2710 road_sign_class,
2711 road_sign_code,
2712 vc_option,
2713 validity,
2714 value,
2715 unit,
2716 }
2717 }
2718 }
2719 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2720 #[rasn(delegate, value("0..=7"))]
2721 pub struct VcOption(pub u8);
2722 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2723 #[rasn(choice, automatic_tags)]
2724 #[non_exhaustive]
2725 pub enum VehicleCharacteristicsFixValues {
2726 simpleVehicleType(StationType),
2727 euVehicleCategoryCode(EuVehicleCategoryCode),
2728 iso3833VehicleType(Iso3833VehicleType),
2729 euroAndCo2value(EnvironmentalCharacteristics),
2730 engineCharacteristics(EngineCharacteristics),
2731 loadType(LoadType),
2732 usage(VehicleRole),
2733 }
2734 #[doc = " new DF in V2"]
2735 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2736 #[rasn(delegate, size("1..=4", extensible))]
2737 pub struct VehicleCharacteristicsFixValuesList(pub SequenceOf<VehicleCharacteristicsFixValues>);
2738 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2739 #[rasn(delegate, size("1..=8", extensible))]
2740 pub struct VehicleCharacteristicsList(pub SequenceOf<CompleteVehicleCharacteristics>);
2741 #[doc = " Inner type "]
2742 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2743 #[rasn(choice, automatic_tags)]
2744 #[non_exhaustive]
2745 pub enum VehicleCharacteristicsRangesLimits {
2746 #[rasn(value("0..=7"))]
2747 numberOfAxles(u8),
2748 vehicleDimensions(VehicleDimensions),
2749 vehicleWeightLimits(VehicleWeightLimits),
2750 axleWeightLimits(AxleWeightLimits),
2751 passengerCapacity(PassengerCapacity),
2752 exhaustEmissionValues(ExhaustEmissionValues),
2753 dieselEmissionValues(DieselEmissionValues),
2754 soundLevel(SoundLevel),
2755 }
2756 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2757 #[rasn(automatic_tags)]
2758 pub struct VehicleCharacteristicsRanges {
2759 #[rasn(identifier = "comparisonOperator")]
2760 pub comparison_operator: ComparisonOperator,
2761 pub limits: VehicleCharacteristicsRangesLimits,
2762 }
2763 impl VehicleCharacteristicsRanges {
2764 pub fn new(
2765 comparison_operator: ComparisonOperator,
2766 limits: VehicleCharacteristicsRangesLimits,
2767 ) -> Self {
2768 Self {
2769 comparison_operator,
2770 limits,
2771 }
2772 }
2773 }
2774 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2775 #[rasn(delegate, size("1..=4", extensible))]
2776 pub struct VehicleCharacteristicsRangesList(pub SequenceOf<VehicleCharacteristicsRanges>);
2777 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2778 #[rasn(delegate, value("0..=7", extensible))]
2779 pub struct WearLevel(pub Integer);
2780 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2781 #[rasn(delegate, value("1..=32", extensible))]
2782 pub struct Zid(pub Integer);
2783 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2784 #[rasn(choice, automatic_tags)]
2785 #[non_exhaustive]
2786 pub enum Zone {
2787 segment(Segment),
2788 area(PolygonalLine),
2789 computedSegment(ComputedSegment),
2790 }
2791 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2792 #[rasn(delegate, size("1..=8", extensible))]
2793 pub struct ZoneIds(pub SequenceOf<Zid>);
2794}
2795#[allow(
2796 non_camel_case_types,
2797 non_snake_case,
2798 non_upper_case_globals,
2799 unused,
2800 clippy::too_many_arguments
2801)]
2802pub mod ivim_pdu_descriptions {
2803 extern crate alloc;
2804 use core::borrow::Borrow;
2805
2806 use rasn::prelude::*;
2807
2808 use super::super::cdd_1_3_1_1::its_container::ItsPduHeader;
2809 use super::ivi::IviStructure;
2810 #[doc = " In vehicle information Message Root"]
2811 #[doc = " This DF includes DEs for the IVIM protocolVersion, the IVI message type identifier _messageID_,"]
2812 #[doc = " the station identifier _stationID_ of the originating ITS-S and the IVI data from ISO TS 19321."]
2813 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2814 #[rasn(automatic_tags)]
2815 pub struct IVIM {
2816 pub header: ItsPduHeader,
2817 pub ivi: IviStructure,
2818 }
2819 impl IVIM {
2820 pub fn new(header: ItsPduHeader, ivi: IviStructure) -> Self {
2821 Self { header, ivi }
2822 }
2823 }
2824}