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 efc_data_dictionary {
9 extern crate alloc;
10 use core::borrow::Borrow;
11
12 use rasn::prelude::*;
13 #[doc = " Clause 5.3\tSingle level data types"]
14 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
15 #[rasn(automatic_tags)]
16 pub struct AxleWeightLimits {
17 #[rasn(identifier = "maxLadenWeightOnAxle1")]
18 pub max_laden_weight_on_axle1: Int2Unsigned,
19 #[rasn(identifier = "maxLadenWeightOnAxle2")]
20 pub max_laden_weight_on_axle2: Int2Unsigned,
21 #[rasn(identifier = "maxLadenWeightOnAxle3")]
22 pub max_laden_weight_on_axle3: Int2Unsigned,
23 #[rasn(identifier = "maxLadenWeightOnAxle4")]
24 pub max_laden_weight_on_axle4: Int2Unsigned,
25 #[rasn(identifier = "maxLadenWeightOnAxle5")]
26 pub max_laden_weight_on_axle5: Int2Unsigned,
27 }
28 impl AxleWeightLimits {
29 pub fn new(
30 max_laden_weight_on_axle1: Int2Unsigned,
31 max_laden_weight_on_axle2: Int2Unsigned,
32 max_laden_weight_on_axle3: Int2Unsigned,
33 max_laden_weight_on_axle4: Int2Unsigned,
34 max_laden_weight_on_axle5: Int2Unsigned,
35 ) -> Self {
36 Self {
37 max_laden_weight_on_axle1,
38 max_laden_weight_on_axle2,
39 max_laden_weight_on_axle3,
40 max_laden_weight_on_axle4,
41 max_laden_weight_on_axle5,
42 }
43 }
44 }
45 #[doc = " Int2Signed ::=\tINTEGER (-32768..32767)"]
46 #[doc = " Int3Unsigned ::= INTEGER (0..16777215)"]
47 #[doc = " Int4Unsigned ::= INTEGER (0..4294967295)"]
48 #[doc = " Int4Signed ::= INTEGER (-2147483648..2147483647)"]
49 #[doc = " 5.2\tSubtypes of simple data types"]
50 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
51 #[rasn(delegate, value("0..=15"))]
52 pub struct CopValue(pub u8);
53 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
54 #[rasn(automatic_tags)]
55 pub struct DieselEmissionValues {
56 pub particulate: Particulate,
57 #[rasn(identifier = "absorptionCoeff")]
58 pub absorption_coeff: Int2Unsigned,
59 }
60 impl DieselEmissionValues {
61 pub fn new(particulate: Particulate, absorption_coeff: Int2Unsigned) -> Self {
62 Self {
63 particulate,
64 absorption_coeff,
65 }
66 }
67 }
68 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
69 #[rasn(delegate, value("0..=1"))]
70 pub struct EmissionUnit(pub u8);
71 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
72 #[rasn(delegate, value("0..=255"))]
73 pub struct EngineCharacteristics(pub u8);
74 #[doc = " Clause 5.4\tTwo level data types"]
75 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
76 #[rasn(automatic_tags)]
77 pub struct EnvironmentalCharacteristics {
78 #[rasn(identifier = "euroValue")]
79 pub euro_value: EuroValue,
80 #[rasn(identifier = "copValue")]
81 pub cop_value: CopValue,
82 }
83 impl EnvironmentalCharacteristics {
84 pub fn new(euro_value: EuroValue, cop_value: CopValue) -> Self {
85 Self {
86 euro_value,
87 cop_value,
88 }
89 }
90 }
91 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
92 #[rasn(delegate, value("0..=15"))]
93 pub struct EuroValue(pub u8);
94 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
95 #[rasn(automatic_tags)]
96 pub struct ExhaustEmissionValues {
97 #[rasn(identifier = "unitType")]
98 pub unit_type: EmissionUnit,
99 #[rasn(value("0..=32767"), identifier = "emissionCo")]
100 pub emission_co: u16,
101 #[rasn(identifier = "emissionHc")]
102 pub emission_hc: Int2Unsigned,
103 #[rasn(identifier = "emissionNox")]
104 pub emission_nox: Int2Unsigned,
105 #[rasn(identifier = "emissionHcNox")]
106 pub emission_hc_nox: Int2Unsigned,
107 }
108 impl ExhaustEmissionValues {
109 pub fn new(
110 unit_type: EmissionUnit,
111 emission_co: u16,
112 emission_hc: Int2Unsigned,
113 emission_nox: Int2Unsigned,
114 emission_hc_nox: Int2Unsigned,
115 ) -> Self {
116 Self {
117 unit_type,
118 emission_co,
119 emission_hc,
120 emission_nox,
121 emission_hc_nox,
122 }
123 }
124 }
125 #[doc = " useful subtypes (with no semantics associated)"]
126 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
127 #[rasn(delegate, value("0..=255"))]
128 pub struct Int1Unsigned(pub u8);
129 #[doc = " Int1Signed ::= INTEGER (-128..127)"]
130 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
131 #[rasn(delegate, value("0..=65535"))]
132 pub struct Int2Unsigned(pub u16);
133 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
134 #[rasn(automatic_tags)]
135 pub struct Particulate {
136 #[rasn(identifier = "unitType")]
137 pub unit_type: EmissionUnit,
138 #[rasn(value("0..=32767"))]
139 pub value: u16,
140 }
141 impl Particulate {
142 pub fn new(unit_type: EmissionUnit, value: u16) -> Self {
143 Self { unit_type, value }
144 }
145 }
146 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
147 #[rasn(automatic_tags)]
148 pub struct PassengerCapacity {
149 #[rasn(identifier = "numberOfSeats")]
150 pub number_of_seats: Int1Unsigned,
151 #[rasn(identifier = "numberOfStandingPlaces")]
152 pub number_of_standing_places: Int1Unsigned,
153 }
154 impl PassengerCapacity {
155 pub fn new(number_of_seats: Int1Unsigned, number_of_standing_places: Int1Unsigned) -> Self {
156 Self {
157 number_of_seats,
158 number_of_standing_places,
159 }
160 }
161 }
162 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
163 #[rasn(automatic_tags)]
164 pub struct SoundLevel {
165 #[rasn(identifier = "soundStationary")]
166 pub sound_stationary: Int1Unsigned,
167 #[rasn(identifier = "soundDriveBy")]
168 pub sound_drive_by: Int1Unsigned,
169 }
170 impl SoundLevel {
171 pub fn new(sound_stationary: Int1Unsigned, sound_drive_by: Int1Unsigned) -> Self {
172 Self {
173 sound_stationary,
174 sound_drive_by,
175 }
176 }
177 }
178 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
179 #[rasn(automatic_tags)]
180 pub struct VehicleDimensions {
181 #[rasn(identifier = "vehicleLengthOverall")]
182 pub vehicle_length_overall: Int1Unsigned,
183 #[rasn(identifier = "vehicleHeightOverall")]
184 pub vehicle_height_overall: Int1Unsigned,
185 #[rasn(identifier = "vehicleWidthOverall")]
186 pub vehicle_width_overall: Int1Unsigned,
187 }
188 impl VehicleDimensions {
189 pub fn new(
190 vehicle_length_overall: Int1Unsigned,
191 vehicle_height_overall: Int1Unsigned,
192 vehicle_width_overall: Int1Unsigned,
193 ) -> Self {
194 Self {
195 vehicle_length_overall,
196 vehicle_height_overall,
197 vehicle_width_overall,
198 }
199 }
200 }
201 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
202 #[rasn(automatic_tags)]
203 pub struct VehicleWeightLimits {
204 #[rasn(identifier = "vehicleMaxLadenWeight")]
205 pub vehicle_max_laden_weight: Int2Unsigned,
206 #[rasn(identifier = "vehicleTrainMaximumWeight")]
207 pub vehicle_train_maximum_weight: Int2Unsigned,
208 #[rasn(identifier = "vehicleWeightUnladen")]
209 pub vehicle_weight_unladen: Int2Unsigned,
210 }
211 impl VehicleWeightLimits {
212 pub fn new(
213 vehicle_max_laden_weight: Int2Unsigned,
214 vehicle_train_maximum_weight: Int2Unsigned,
215 vehicle_weight_unladen: Int2Unsigned,
216 ) -> Self {
217 Self {
218 vehicle_max_laden_weight,
219 vehicle_train_maximum_weight,
220 vehicle_weight_unladen,
221 }
222 }
223 }
224}
225#[allow(
226 non_camel_case_types,
227 non_snake_case,
228 non_upper_case_globals,
229 unused,
230 clippy::too_many_arguments
231)]
232pub mod gdd {
233 extern crate alloc;
234 use core::borrow::Borrow;
235
236 use rasn::prelude::*;
237 #[doc = " Definition of data elements used in ISO 14823 attributes"]
238 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
239 #[rasn(delegate, identifier = "Code-Units", value("0..=15"))]
240 pub struct CodeUnits(pub u8);
241 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
242 #[rasn(automatic_tags, identifier = "DDD-IO")]
243 pub struct DDDIO {
244 #[rasn(value("0..=7"), identifier = "arrowDirection")]
245 pub arrow_direction: u8,
246 #[rasn(identifier = "destPlace")]
247 pub dest_place: Option<DestinationPlaces>,
248 #[rasn(identifier = "destRoad")]
249 pub dest_road: Option<DestinationRoads>,
250 #[rasn(value("1..=999"), identifier = "roadNumberIdentifier")]
251 pub road_number_identifier: Option<u16>,
252 #[rasn(value("1..=999"), identifier = "streetName")]
253 pub street_name: Option<u16>,
254 #[rasn(identifier = "streetNameText")]
255 pub street_name_text: Option<Utf8String>,
256 #[rasn(identifier = "distanceToDivergingPoint")]
257 pub distance_to_diverging_point: Option<DistanceOrDuration>,
258 #[rasn(identifier = "distanceToDestinationPlace")]
259 pub distance_to_destination_place: Option<DistanceOrDuration>,
260 }
261 impl DDDIO {
262 pub fn new(
263 arrow_direction: u8,
264 dest_place: Option<DestinationPlaces>,
265 dest_road: Option<DestinationRoads>,
266 road_number_identifier: Option<u16>,
267 street_name: Option<u16>,
268 street_name_text: Option<Utf8String>,
269 distance_to_diverging_point: Option<DistanceOrDuration>,
270 distance_to_destination_place: Option<DistanceOrDuration>,
271 ) -> Self {
272 Self {
273 arrow_direction,
274 dest_place,
275 dest_road,
276 road_number_identifier,
277 street_name,
278 street_name_text,
279 distance_to_diverging_point,
280 distance_to_destination_place,
281 }
282 }
283 }
284 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
285 #[rasn(delegate, size("1..=8", extensible), identifier = "DDD-IO-LIST")]
286 pub struct DDDIOLIST(pub SequenceOf<DDDIO>);
287 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
288 #[rasn(delegate)]
289 pub struct DayOfWeek(pub FixedBitString<8usize>);
290 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
291 #[rasn(automatic_tags)]
292 pub struct DestinationPlace {
293 #[rasn(identifier = "destType")]
294 pub dest_type: DestinationType,
295 #[rasn(value("0.."), identifier = "destRSCode")]
296 pub dest_rscode: Option<GddStructure>,
297 #[rasn(identifier = "destBlob")]
298 pub dest_blob: Option<OctetString>,
299 #[rasn(value("1..=999"), identifier = "placeNameIdentification")]
300 pub place_name_identification: Option<u16>,
301 #[rasn(identifier = "placeNameText")]
302 pub place_name_text: Option<Utf8String>,
303 }
304 impl DestinationPlace {
305 pub fn new(
306 dest_type: DestinationType,
307 dest_rscode: Option<GddStructure>,
308 dest_blob: Option<OctetString>,
309 place_name_identification: Option<u16>,
310 place_name_text: Option<Utf8String>,
311 ) -> Self {
312 Self {
313 dest_type,
314 dest_rscode,
315 dest_blob,
316 place_name_identification,
317 place_name_text,
318 }
319 }
320 }
321 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
322 #[rasn(delegate, size("1..=4", extensible))]
323 pub struct DestinationPlaces(pub SequenceOf<DestinationPlace>);
324 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
325 #[rasn(automatic_tags)]
326 pub struct DestinationRoad {
327 #[rasn(identifier = "derType")]
328 pub der_type: DestinationRoadType,
329 #[rasn(value("1..=999"), identifier = "roadNumberIdentifier")]
330 pub road_number_identifier: Option<u16>,
331 #[rasn(identifier = "roadNumberText")]
332 pub road_number_text: Option<Utf8String>,
333 }
334 impl DestinationRoad {
335 pub fn new(
336 der_type: DestinationRoadType,
337 road_number_identifier: Option<u16>,
338 road_number_text: Option<Utf8String>,
339 ) -> Self {
340 Self {
341 der_type,
342 road_number_identifier,
343 road_number_text,
344 }
345 }
346 }
347 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
348 #[rasn(delegate, value("0..=15", extensible))]
349 pub struct DestinationRoadType(pub Integer);
350 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
351 #[rasn(delegate, size("1..=4", extensible))]
352 pub struct DestinationRoads(pub SequenceOf<DestinationRoad>);
353 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
354 #[rasn(delegate, value("0..=15", extensible))]
355 pub struct DestinationType(pub Integer);
356 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
357 #[rasn(automatic_tags)]
358 pub struct Distance {
359 #[rasn(value("1..=16384"))]
360 pub value: u16,
361 #[rasn(value("2..=8"))]
362 pub unit: CodeUnits,
363 }
364 impl Distance {
365 pub fn new(value: u16, unit: CodeUnits) -> Self {
366 Self { value, unit }
367 }
368 }
369 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
370 #[rasn(automatic_tags)]
371 pub struct DistanceOrDuration {
372 #[rasn(value("1..=16384"))]
373 pub value: u16,
374 #[rasn(value("2..=9"))]
375 pub unit: CodeUnits,
376 }
377 impl DistanceOrDuration {
378 pub fn new(value: u16, unit: CodeUnits) -> Self {
379 Self { value, unit }
380 }
381 }
382 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
383 #[rasn(choice, automatic_tags)]
384 pub enum GddAttribute {
385 dtm(InternationalSignApplicablePeriod),
386 edt(InternationalSignExemptedApplicablePeriod),
387 dfl(InternationalSignDirectionalFlowOfLane),
388 ved(InternationalSignApplicableVehicleDimensions),
389 spe(InternationalSignSpeedLimits),
390 roi(InternationalSignRateOfIncline),
391 dbv(InternationalSignDistanceBetweenVehicles),
392 ddd(InternationalSignDestinationInformation),
393 set(InternationalSignSection),
394 nol(InternationalSignNumberOfLane),
395 }
396 #[doc = " Definition of the single ISO 14823 Attributes"]
397 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
398 #[rasn(delegate, size("1..=8", extensible))]
399 pub struct GddAttributes(pub SequenceOf<GddAttribute>);
400 #[doc = " Inner type "]
401 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
402 #[rasn(enumerated)]
403 #[non_exhaustive]
404 pub enum GddStructurePictogramCodeServiceCategoryCodeTrafficSignPictogram {
405 dangerWarning = 0,
406 regulatory = 1,
407 informative = 2,
408 }
409 #[doc = " Inner type "]
410 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
411 #[rasn(enumerated)]
412 #[non_exhaustive]
413 pub enum GddStructurePictogramCodeServiceCategoryCodePublicFacilitiesPictogram {
414 publicFacilities = 0,
415 }
416 #[doc = " Inner type "]
417 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
418 #[rasn(enumerated)]
419 #[non_exhaustive]
420 pub enum GddStructurePictogramCodeServiceCategoryCodeAmbientOrRoadConditionPictogram {
421 ambientCondition = 0,
422 roadCondition = 1,
423 }
424 #[doc = " Inner type "]
425 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
426 #[rasn(choice, automatic_tags)]
427 #[non_exhaustive]
428 pub enum GddStructurePictogramCodeServiceCategoryCode {
429 trafficSignPictogram(GddStructurePictogramCodeServiceCategoryCodeTrafficSignPictogram),
430 publicFacilitiesPictogram(
431 GddStructurePictogramCodeServiceCategoryCodePublicFacilitiesPictogram,
432 ),
433 ambientOrRoadConditionPictogram(
434 GddStructurePictogramCodeServiceCategoryCodeAmbientOrRoadConditionPictogram,
435 ),
436 }
437 #[doc = " Inner type "]
438 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
439 #[rasn(automatic_tags)]
440 pub struct GddStructurePictogramCodePictogramCategoryCode {
441 #[rasn(value("1..=9"))]
442 pub nature: u8,
443 #[rasn(value("0..=99"), identifier = "serialNumber")]
444 pub serial_number: u8,
445 }
446 impl GddStructurePictogramCodePictogramCategoryCode {
447 pub fn new(nature: u8, serial_number: u8) -> Self {
448 Self {
449 nature,
450 serial_number,
451 }
452 }
453 }
454 #[doc = " Inner type "]
455 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
456 #[rasn(automatic_tags)]
457 pub struct GddStructurePictogramCode {
458 #[rasn(size("2"), identifier = "countryCode")]
459 pub country_code: Option<OctetString>,
460 #[rasn(identifier = "serviceCategoryCode")]
461 pub service_category_code: GddStructurePictogramCodeServiceCategoryCode,
462 #[rasn(identifier = "pictogramCategoryCode")]
463 pub pictogram_category_code: GddStructurePictogramCodePictogramCategoryCode,
464 }
465 impl GddStructurePictogramCode {
466 pub fn new(
467 country_code: Option<OctetString>,
468 service_category_code: GddStructurePictogramCodeServiceCategoryCode,
469 pictogram_category_code: GddStructurePictogramCodePictogramCategoryCode,
470 ) -> Self {
471 Self {
472 country_code,
473 service_category_code,
474 pictogram_category_code,
475 }
476 }
477 }
478 #[doc = "Definition of GDD Structure"]
479 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
480 #[rasn(automatic_tags)]
481 pub struct GddStructure {
482 #[rasn(identifier = "pictogramCode")]
483 pub pictogram_code: GddStructurePictogramCode,
484 pub attributes: Option<GddAttributes>,
485 }
486 impl GddStructure {
487 pub fn new(
488 pictogram_code: GddStructurePictogramCode,
489 attributes: Option<GddAttributes>,
490 ) -> Self {
491 Self {
492 pictogram_code,
493 attributes,
494 }
495 }
496 }
497 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
498 #[rasn(automatic_tags)]
499 pub struct HoursMinutes {
500 #[rasn(value("0..=23"))]
501 pub hours: u8,
502 #[rasn(value("0..=59"))]
503 pub mins: u8,
504 }
505 impl HoursMinutes {
506 pub fn new(hours: u8, mins: u8) -> Self {
507 Self { hours, mins }
508 }
509 }
510 #[doc = " Inner type "]
511 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
512 #[rasn(automatic_tags)]
513 pub struct InternationalSignApplicablePeriodYear {
514 #[rasn(value("2000..=2127", extensible), identifier = "yearRangeStartYear")]
515 pub year_range_start_year: Integer,
516 #[rasn(value("2000..=2127", extensible), identifier = "yearRangeEndYear")]
517 pub year_range_end_year: Integer,
518 }
519 impl InternationalSignApplicablePeriodYear {
520 pub fn new(year_range_start_year: Integer, year_range_end_year: Integer) -> Self {
521 Self {
522 year_range_start_year,
523 year_range_end_year,
524 }
525 }
526 }
527 #[doc = " Inner type "]
528 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
529 #[rasn(automatic_tags)]
530 pub struct InternationalSignApplicablePeriodMonthDay {
531 #[rasn(identifier = "dateRangeStartMonthDay")]
532 pub date_range_start_month_day: MonthDay,
533 #[rasn(identifier = "dateRangeEndMonthDay")]
534 pub date_range_end_month_day: MonthDay,
535 }
536 impl InternationalSignApplicablePeriodMonthDay {
537 pub fn new(
538 date_range_start_month_day: MonthDay,
539 date_range_end_month_day: MonthDay,
540 ) -> Self {
541 Self {
542 date_range_start_month_day,
543 date_range_end_month_day,
544 }
545 }
546 }
547 #[doc = " Inner type "]
548 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
549 #[rasn(automatic_tags)]
550 pub struct InternationalSignApplicablePeriodHourMinutes {
551 #[rasn(identifier = "timeRangeStartTime")]
552 pub time_range_start_time: HoursMinutes,
553 #[rasn(identifier = "timeRangeEndTime")]
554 pub time_range_end_time: HoursMinutes,
555 }
556 impl InternationalSignApplicablePeriodHourMinutes {
557 pub fn new(time_range_start_time: HoursMinutes, time_range_end_time: HoursMinutes) -> Self {
558 Self {
559 time_range_start_time,
560 time_range_end_time,
561 }
562 }
563 }
564 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
565 #[rasn(automatic_tags, identifier = "InternationalSign-applicablePeriod")]
566 pub struct InternationalSignApplicablePeriod {
567 pub year: Option<InternationalSignApplicablePeriodYear>,
568 #[rasn(identifier = "month-day")]
569 pub month_day: Option<InternationalSignApplicablePeriodMonthDay>,
570 #[rasn(identifier = "repeatingPeriodDayTypes")]
571 pub repeating_period_day_types: Option<RepeatingPeriodDayTypes>,
572 #[rasn(identifier = "hourMinutes")]
573 pub hour_minutes: Option<InternationalSignApplicablePeriodHourMinutes>,
574 #[rasn(identifier = "dateRangeOfWeek")]
575 pub date_range_of_week: Option<DayOfWeek>,
576 #[rasn(identifier = "durationHourMinute")]
577 pub duration_hour_minute: Option<HoursMinutes>,
578 }
579 impl InternationalSignApplicablePeriod {
580 pub fn new(
581 year: Option<InternationalSignApplicablePeriodYear>,
582 month_day: Option<InternationalSignApplicablePeriodMonthDay>,
583 repeating_period_day_types: Option<RepeatingPeriodDayTypes>,
584 hour_minutes: Option<InternationalSignApplicablePeriodHourMinutes>,
585 date_range_of_week: Option<DayOfWeek>,
586 duration_hour_minute: Option<HoursMinutes>,
587 ) -> Self {
588 Self {
589 year,
590 month_day,
591 repeating_period_day_types,
592 hour_minutes,
593 date_range_of_week,
594 duration_hour_minute,
595 }
596 }
597 }
598 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
599 #[rasn(
600 automatic_tags,
601 identifier = "InternationalSign-applicableVehicleDimensions"
602 )]
603 pub struct InternationalSignApplicableVehicleDimensions {
604 #[rasn(identifier = "vehicleHeight")]
605 pub vehicle_height: Option<Distance>,
606 #[rasn(identifier = "vehicleWidth")]
607 pub vehicle_width: Option<Distance>,
608 #[rasn(identifier = "vehicleLength")]
609 pub vehicle_length: Option<Distance>,
610 #[rasn(identifier = "vehicleWeight")]
611 pub vehicle_weight: Option<Weight>,
612 }
613 impl InternationalSignApplicableVehicleDimensions {
614 pub fn new(
615 vehicle_height: Option<Distance>,
616 vehicle_width: Option<Distance>,
617 vehicle_length: Option<Distance>,
618 vehicle_weight: Option<Weight>,
619 ) -> Self {
620 Self {
621 vehicle_height,
622 vehicle_width,
623 vehicle_length,
624 vehicle_weight,
625 }
626 }
627 }
628 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
629 #[rasn(
630 automatic_tags,
631 identifier = "InternationalSign-destinationInformation"
632 )]
633 pub struct InternationalSignDestinationInformation {
634 #[rasn(value("1..=128"), identifier = "junctionDirection")]
635 pub junction_direction: Option<u8>,
636 #[rasn(value("1..=128"), identifier = "roundaboutCwDirection")]
637 pub roundabout_cw_direction: Option<u8>,
638 #[rasn(value("1..=128"), identifier = "roundaboutCcwDirection")]
639 pub roundabout_ccw_direction: Option<u8>,
640 #[rasn(identifier = "ioList")]
641 pub io_list: DDDIOLIST,
642 }
643 impl InternationalSignDestinationInformation {
644 pub fn new(
645 junction_direction: Option<u8>,
646 roundabout_cw_direction: Option<u8>,
647 roundabout_ccw_direction: Option<u8>,
648 io_list: DDDIOLIST,
649 ) -> Self {
650 Self {
651 junction_direction,
652 roundabout_cw_direction,
653 roundabout_ccw_direction,
654 io_list,
655 }
656 }
657 }
658 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
659 #[rasn(
660 delegate,
661 identifier = "InternationalSign-directionalFlowOfLane",
662 value("1..=8")
663 )]
664 pub struct InternationalSignDirectionalFlowOfLane(pub u8);
665 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
666 #[rasn(delegate, identifier = "InternationalSign-distanceBetweenVehicles")]
667 pub struct InternationalSignDistanceBetweenVehicles(pub Distance);
668 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
669 #[rasn(delegate, identifier = "InternationalSign-exemptedApplicablePeriod")]
670 pub struct InternationalSignExemptedApplicablePeriod(pub InternationalSignApplicablePeriod);
671 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
672 #[rasn(
673 delegate,
674 identifier = "InternationalSign-numberOfLane",
675 value("0..=99")
676 )]
677 pub struct InternationalSignNumberOfLane(pub u8);
678 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
679 #[rasn(
680 delegate,
681 identifier = "InternationalSign-rateOfIncline",
682 value("1..=32")
683 )]
684 pub struct InternationalSignRateOfIncline(pub u8);
685 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
686 #[rasn(automatic_tags, identifier = "InternationalSign-section")]
687 pub struct InternationalSignSection {
688 #[rasn(identifier = "startingPointLength")]
689 pub starting_point_length: Option<Distance>,
690 #[rasn(identifier = "continuityLength")]
691 pub continuity_length: Option<Distance>,
692 }
693 impl InternationalSignSection {
694 pub fn new(
695 starting_point_length: Option<Distance>,
696 continuity_length: Option<Distance>,
697 ) -> Self {
698 Self {
699 starting_point_length,
700 continuity_length,
701 }
702 }
703 }
704 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
705 #[rasn(automatic_tags, identifier = "InternationalSign-speedLimits")]
706 pub struct InternationalSignSpeedLimits {
707 #[rasn(value("0..=250"), identifier = "speedLimitMax")]
708 pub speed_limit_max: Option<u8>,
709 #[rasn(value("0..=250"), identifier = "speedLimitMin")]
710 pub speed_limit_min: Option<u8>,
711 #[rasn(value("0..=1"))]
712 pub unit: CodeUnits,
713 }
714 impl InternationalSignSpeedLimits {
715 pub fn new(
716 speed_limit_max: Option<u8>,
717 speed_limit_min: Option<u8>,
718 unit: CodeUnits,
719 ) -> Self {
720 Self {
721 speed_limit_max,
722 speed_limit_min,
723 unit,
724 }
725 }
726 }
727 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
728 #[rasn(automatic_tags)]
729 pub struct MonthDay {
730 #[rasn(value("1..=12"))]
731 pub month: u8,
732 #[rasn(value("1..=31"))]
733 pub day: u8,
734 }
735 impl MonthDay {
736 pub fn new(month: u8, day: u8) -> Self {
737 Self { month, day }
738 }
739 }
740 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
741 #[rasn(delegate)]
742 pub struct RepeatingPeriodDayTypes(pub FixedBitString<4usize>);
743 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
744 #[rasn(automatic_tags)]
745 pub struct Weight {
746 #[rasn(value("1..=16384"))]
747 pub value: u16,
748 #[rasn(value("10..=12"))]
749 pub unit: CodeUnits,
750 }
751 impl Weight {
752 pub fn new(value: u16, unit: CodeUnits) -> Self {
753 Self { value, unit }
754 }
755 }
756}
757#[allow(
758 non_camel_case_types,
759 non_snake_case,
760 non_upper_case_globals,
761 unused,
762 clippy::too_many_arguments
763)]
764pub mod ivi {
765 extern crate alloc;
766 use core::borrow::Borrow;
767
768 use rasn::prelude::*;
769
770 use super::super::cdd_2_2_1::etsi_its_cdd::{
771 ActionIdList,
772 Altitude,
773 DangerousGoodsBasic,
774 DeltaLatitude,
775 DeltaLongitude,
776 DeltaReferencePosition,
777 Direction,
778 EuVehicleCategoryCode,
779 Heading,
780 HeadingValue,
781 Identifier1B,
782 Iso3833VehicleType,
783 LanePosition,
784 LaneType,
785 LaneWidth,
786 Latitude,
787 Longitude,
788 MapReference,
789 Provider,
790 ReferencePosition,
791 RoadType,
792 SpecialTransportType,
793 Speed,
794 SpeedValue,
795 StandardLength9b,
796 StationType,
797 TimestampIts,
798 VarLengthNumber,
799 VehicleRole,
800 };
801 use super::efc_data_dictionary::{
802 AxleWeightLimits,
803 DieselEmissionValues,
804 EngineCharacteristics,
805 EnvironmentalCharacteristics,
806 ExhaustEmissionValues,
807 PassengerCapacity,
808 SoundLevel,
809 VehicleDimensions,
810 VehicleWeightLimits,
811 };
812 use super::gdd::{
813 InternationalSignApplicablePeriod,
814 InternationalSignApplicableVehicleDimensions,
815 InternationalSignDestinationInformation,
816 InternationalSignDirectionalFlowOfLane,
817 InternationalSignDistanceBetweenVehicles,
818 InternationalSignExemptedApplicablePeriod,
819 InternationalSignRateOfIncline,
820 InternationalSignSpeedLimits,
821 };
822 #[doc = " Extension in V3.1"]
823 #[doc = " Definition of Data Frames"]
824 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
825 #[rasn(automatic_tags)]
826 pub struct AbsolutePosition {
827 pub latitude: Latitude,
828 pub longitude: Longitude,
829 }
830 impl AbsolutePosition {
831 pub fn new(latitude: Latitude, longitude: Longitude) -> Self {
832 Self {
833 latitude,
834 longitude,
835 }
836 }
837 }
838 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
839 #[rasn(automatic_tags)]
840 pub struct AbsolutePositionWAltitude {
841 pub latitude: Latitude,
842 pub longitude: Longitude,
843 pub altitude: Altitude,
844 }
845 impl AbsolutePositionWAltitude {
846 pub fn new(latitude: Latitude, longitude: Longitude, altitude: Altitude) -> Self {
847 Self {
848 latitude,
849 longitude,
850 altitude,
851 }
852 }
853 }
854 #[doc = " Definition of data frames which are lists of data frames"]
855 #[doc = " note: those definitions are to avoid \"implicit type definitions\" but are bit compatible with V1"]
856 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
857 #[rasn(delegate, size("1..=8", extensible))]
858 pub struct AbsolutePositions(pub SequenceOf<AbsolutePosition>);
859 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
860 #[rasn(delegate, size("1..=8", extensible))]
861 pub struct AbsolutePositionsWAltitude(pub SequenceOf<AbsolutePositionWAltitude>);
862 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
863 #[rasn(automatic_tags)]
864 pub struct AnyCatalogue {
865 pub owner: Provider,
866 #[rasn(value("0..=255"))]
867 pub version: u8,
868 #[rasn(value("0..=65535"), identifier = "pictogramCode")]
869 pub pictogram_code: u16,
870 #[rasn(value("0..=65535"))]
871 pub value: Option<u16>,
872 pub unit: Option<RSCUnit>,
873 pub attributes: Option<ISO14823Attributes>,
874 }
875 impl AnyCatalogue {
876 pub fn new(
877 owner: Provider,
878 version: u8,
879 pictogram_code: u16,
880 value: Option<u16>,
881 unit: Option<RSCUnit>,
882 attributes: Option<ISO14823Attributes>,
883 ) -> Self {
884 Self {
885 owner,
886 version,
887 pictogram_code,
888 value,
889 unit,
890 attributes,
891 }
892 }
893 }
894 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
895 #[rasn(delegate, size("1..=16", extensible))]
896 pub struct AutomatedVehicleContainer(pub SequenceOf<AvcPart>);
897 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
898 #[rasn(automatic_tags)]
899 #[non_exhaustive]
900 pub struct AutomatedVehicleRule {
901 pub priority: PriorityLevel,
902 #[rasn(identifier = "allowedSaeAutomationLevels")]
903 pub allowed_sae_automation_levels: SaeAutomationLevels,
904 #[rasn(identifier = "minGapBetweenVehicles")]
905 pub min_gap_between_vehicles: Option<GapBetweenVehicles>,
906 #[rasn(identifier = "recGapBetweenVehicles")]
907 pub rec_gap_between_vehicles: Option<GapBetweenVehicles>,
908 #[rasn(identifier = "automatedVehicleMaxSpeedLimit")]
909 pub automated_vehicle_max_speed_limit: Option<SpeedValue>,
910 #[rasn(identifier = "automatedVehicleMinSpeedLimit")]
911 pub automated_vehicle_min_speed_limit: Option<SpeedValue>,
912 #[rasn(identifier = "automatedVehicleSpeedRecommendation")]
913 pub automated_vehicle_speed_recommendation: Option<SpeedValue>,
914 #[rasn(identifier = "roadSignCodes")]
915 pub road_sign_codes: Option<RoadSignCodes>,
916 #[rasn(identifier = "extraText")]
917 pub extra_text: Option<ConstraintTextLines2>,
918 }
919 impl AutomatedVehicleRule {
920 pub fn new(
921 priority: PriorityLevel,
922 allowed_sae_automation_levels: SaeAutomationLevels,
923 min_gap_between_vehicles: Option<GapBetweenVehicles>,
924 rec_gap_between_vehicles: Option<GapBetweenVehicles>,
925 automated_vehicle_max_speed_limit: Option<SpeedValue>,
926 automated_vehicle_min_speed_limit: Option<SpeedValue>,
927 automated_vehicle_speed_recommendation: Option<SpeedValue>,
928 road_sign_codes: Option<RoadSignCodes>,
929 extra_text: Option<ConstraintTextLines2>,
930 ) -> Self {
931 Self {
932 priority,
933 allowed_sae_automation_levels,
934 min_gap_between_vehicles,
935 rec_gap_between_vehicles,
936 automated_vehicle_max_speed_limit,
937 automated_vehicle_min_speed_limit,
938 automated_vehicle_speed_recommendation,
939 road_sign_codes,
940 extra_text,
941 }
942 }
943 }
944 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
945 #[rasn(delegate, size("1..=5"))]
946 pub struct AutomatedVehicleRules(pub SequenceOf<AutomatedVehicleRule>);
947 #[doc = " new container in V2"]
948 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
949 #[rasn(automatic_tags)]
950 #[non_exhaustive]
951 pub struct AvcPart {
952 #[rasn(identifier = "detectionZoneIds")]
953 pub detection_zone_ids: Option<ZoneIds>,
954 #[rasn(identifier = "relevanceZoneIds")]
955 pub relevance_zone_ids: ZoneIds,
956 pub direction: Option<Direction>,
957 #[rasn(identifier = "applicableLanes")]
958 pub applicable_lanes: Option<LanePositions>,
959 #[rasn(identifier = "vehicleCharacteristics")]
960 pub vehicle_characteristics: Option<VehicleCharacteristicsList>,
961 #[rasn(identifier = "automatedVehicleRules")]
962 pub automated_vehicle_rules: Option<AutomatedVehicleRules>,
963 #[rasn(identifier = "platooningRules")]
964 pub platooning_rules: Option<PlatooningRules>,
965 }
966 impl AvcPart {
967 pub fn new(
968 detection_zone_ids: Option<ZoneIds>,
969 relevance_zone_ids: ZoneIds,
970 direction: Option<Direction>,
971 applicable_lanes: Option<LanePositions>,
972 vehicle_characteristics: Option<VehicleCharacteristicsList>,
973 automated_vehicle_rules: Option<AutomatedVehicleRules>,
974 platooning_rules: Option<PlatooningRules>,
975 ) -> Self {
976 Self {
977 detection_zone_ids,
978 relevance_zone_ids,
979 direction,
980 applicable_lanes,
981 vehicle_characteristics,
982 automated_vehicle_rules,
983 platooning_rules,
984 }
985 }
986 }
987 #[doc = " Defition of IVI specific data elements "]
988 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
989 #[rasn(delegate, value("-20..=21"))]
990 pub struct BankingAngle(pub i8);
991 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
992 #[rasn(delegate, value("0..=3"))]
993 pub struct ComparisonOperator(pub u8);
994 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
995 #[rasn(automatic_tags)]
996 pub struct CompleteVehicleCharacteristics {
997 pub tractor: Option<TractorCharacteristics>,
998 pub trailer: Option<TrailerCharacteristicsList>,
999 pub train: Option<TrainCharacteristics>,
1000 }
1001 impl CompleteVehicleCharacteristics {
1002 pub fn new(
1003 tractor: Option<TractorCharacteristics>,
1004 trailer: Option<TrailerCharacteristicsList>,
1005 train: Option<TrainCharacteristics>,
1006 ) -> Self {
1007 Self {
1008 tractor,
1009 trailer,
1010 train,
1011 }
1012 }
1013 }
1014 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1015 #[rasn(automatic_tags)]
1016 pub struct ComputedSegment {
1017 #[rasn(identifier = "zoneId")]
1018 pub zone_id: Zid,
1019 #[rasn(identifier = "laneNumber")]
1020 pub lane_number: LanePosition,
1021 #[rasn(identifier = "laneWidth")]
1022 pub lane_width: LaneWidth,
1023 #[rasn(value("-32768..=32767"), identifier = "offsetDistance")]
1024 pub offset_distance: Option<i16>,
1025 #[rasn(identifier = "offsetPosition")]
1026 pub offset_position: Option<DeltaReferencePosition>,
1027 }
1028 impl ComputedSegment {
1029 pub fn new(
1030 zone_id: Zid,
1031 lane_number: LanePosition,
1032 lane_width: LaneWidth,
1033 offset_distance: Option<i16>,
1034 offset_position: Option<DeltaReferencePosition>,
1035 ) -> Self {
1036 Self {
1037 zone_id,
1038 lane_number,
1039 lane_width,
1040 offset_distance,
1041 offset_position,
1042 }
1043 }
1044 }
1045 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1046 #[rasn(delegate, value("0..=15", extensible))]
1047 pub struct Condition(pub Integer);
1048 #[doc = "size extension corrected in V3.1"]
1049 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1050 #[rasn(delegate, size("1..=4", extensible))]
1051 pub struct ConstraintTextLines1(pub SequenceOf<Text>);
1052 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1053 #[rasn(delegate, size("1..=4", extensible))]
1054 pub struct ConstraintTextLines2(pub SequenceOf<Text>);
1055 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1056 #[rasn(delegate, value("0..=127", extensible))]
1057 pub struct ContentId(pub Integer);
1058 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1059 #[rasn(delegate, value("0..=7", extensible))]
1060 pub struct DefinitionAccuracy(pub Integer);
1061 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1062 #[rasn(automatic_tags)]
1063 pub struct DeltaPosition {
1064 #[rasn(identifier = "deltaLatitude")]
1065 pub delta_latitude: DeltaLatitude,
1066 #[rasn(identifier = "deltaLongitude")]
1067 pub delta_longitude: DeltaLongitude,
1068 }
1069 impl DeltaPosition {
1070 pub fn new(delta_latitude: DeltaLatitude, delta_longitude: DeltaLongitude) -> Self {
1071 Self {
1072 delta_latitude,
1073 delta_longitude,
1074 }
1075 }
1076 }
1077 #[doc = " new DF in V2"]
1078 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1079 #[rasn(delegate, size("1..=32", extensible))]
1080 pub struct DeltaPositions(pub SequenceOf<DeltaPosition>);
1081 #[doc = "size extension corrected in V3.1"]
1082 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1083 #[rasn(delegate, size("1..=32", extensible))]
1084 pub struct DeltaReferencePositions(pub SequenceOf<DeltaReferencePosition>);
1085 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1086 #[rasn(delegate, value("0..=255"))]
1087 pub struct Depth(pub u8);
1088 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1089 #[rasn(delegate, value("0..=3"))]
1090 pub struct DriverCharacteristics(pub u8);
1091 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1092 #[rasn(delegate, value("0..=101"))]
1093 pub struct FrictionCoefficient(pub u8);
1094 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1095 #[rasn(delegate, value("0..=255"))]
1096 pub struct GapBetweenVehicles(pub u8);
1097 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1098 #[rasn(delegate, size("1..=16", extensible))]
1099 pub struct GeneralIviContainer(pub SequenceOf<GicPart>);
1100 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1101 #[rasn(automatic_tags)]
1102 #[non_exhaustive]
1103 pub struct GeographicLocationContainer {
1104 #[rasn(identifier = "referencePosition")]
1105 pub reference_position: ReferencePosition,
1106 #[rasn(identifier = "referencePositionTime")]
1107 pub reference_position_time: Option<TimestampIts>,
1108 #[rasn(identifier = "referencePositionHeading")]
1109 pub reference_position_heading: Option<Heading>,
1110 #[rasn(identifier = "referencePositionSpeed")]
1111 pub reference_position_speed: Option<Speed>,
1112 pub parts: GlcParts,
1113 }
1114 impl GeographicLocationContainer {
1115 pub fn new(
1116 reference_position: ReferencePosition,
1117 reference_position_time: Option<TimestampIts>,
1118 reference_position_heading: Option<Heading>,
1119 reference_position_speed: Option<Speed>,
1120 parts: GlcParts,
1121 ) -> Self {
1122 Self {
1123 reference_position,
1124 reference_position_time,
1125 reference_position_heading,
1126 reference_position_speed,
1127 parts,
1128 }
1129 }
1130 }
1131 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1132 #[rasn(automatic_tags)]
1133 #[non_exhaustive]
1134 pub struct GicPart {
1135 #[rasn(identifier = "detectionZoneIds")]
1136 pub detection_zone_ids: Option<ZoneIds>,
1137 #[rasn(identifier = "its-Rrid")]
1138 pub its_rrid: Option<VarLengthNumber>,
1139 #[rasn(identifier = "relevanceZoneIds")]
1140 pub relevance_zone_ids: Option<ZoneIds>,
1141 pub direction: Option<Direction>,
1142 #[rasn(identifier = "driverAwarenessZoneIds")]
1143 pub driver_awareness_zone_ids: Option<ZoneIds>,
1144 #[rasn(value("0..=255"), identifier = "minimumAwarenessTime")]
1145 pub minimum_awareness_time: Option<u8>,
1146 #[rasn(identifier = "applicableLanes")]
1147 pub applicable_lanes: Option<LanePositions>,
1148 #[rasn(identifier = "iviType")]
1149 pub ivi_type: IviType,
1150 #[rasn(identifier = "iviPurpose")]
1151 pub ivi_purpose: Option<IviPurpose>,
1152 #[rasn(identifier = "laneStatus")]
1153 pub lane_status: Option<LaneStatus>,
1154 #[rasn(identifier = "vehicleCharacteristics")]
1155 pub vehicle_characteristics: Option<VehicleCharacteristicsList>,
1156 #[rasn(identifier = "driverCharacteristics")]
1157 pub driver_characteristics: Option<DriverCharacteristics>,
1158 #[rasn(value("1..=4", extensible), identifier = "layoutId")]
1159 pub layout_id: Option<Integer>,
1160 #[rasn(value("1..=64", extensible), identifier = "preStoredlayoutId")]
1161 pub pre_storedlayout_id: Option<Integer>,
1162 #[rasn(identifier = "roadSignCodes")]
1163 pub road_sign_codes: RoadSignCodes,
1164 #[rasn(identifier = "extraText")]
1165 pub extra_text: Option<ConstraintTextLines1>,
1166 }
1167 impl GicPart {
1168 pub fn new(
1169 detection_zone_ids: Option<ZoneIds>,
1170 its_rrid: Option<VarLengthNumber>,
1171 relevance_zone_ids: Option<ZoneIds>,
1172 direction: Option<Direction>,
1173 driver_awareness_zone_ids: Option<ZoneIds>,
1174 minimum_awareness_time: Option<u8>,
1175 applicable_lanes: Option<LanePositions>,
1176 ivi_type: IviType,
1177 ivi_purpose: Option<IviPurpose>,
1178 lane_status: Option<LaneStatus>,
1179 vehicle_characteristics: Option<VehicleCharacteristicsList>,
1180 driver_characteristics: Option<DriverCharacteristics>,
1181 layout_id: Option<Integer>,
1182 pre_storedlayout_id: Option<Integer>,
1183 road_sign_codes: RoadSignCodes,
1184 extra_text: Option<ConstraintTextLines1>,
1185 ) -> Self {
1186 Self {
1187 detection_zone_ids,
1188 its_rrid,
1189 relevance_zone_ids,
1190 direction,
1191 driver_awareness_zone_ids,
1192 minimum_awareness_time,
1193 applicable_lanes,
1194 ivi_type,
1195 ivi_purpose,
1196 lane_status,
1197 vehicle_characteristics,
1198 driver_characteristics,
1199 layout_id,
1200 pre_storedlayout_id,
1201 road_sign_codes,
1202 extra_text,
1203 }
1204 }
1205 }
1206 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1207 #[rasn(automatic_tags)]
1208 #[non_exhaustive]
1209 pub struct GlcPart {
1210 #[rasn(identifier = "zoneId")]
1211 pub zone_id: Zid,
1212 #[rasn(identifier = "laneNumber")]
1213 pub lane_number: Option<LanePosition>,
1214 #[rasn(value("0..=255"), identifier = "zoneExtension")]
1215 pub zone_extension: Option<u8>,
1216 #[rasn(identifier = "zoneHeading")]
1217 pub zone_heading: Option<HeadingValue>,
1218 pub zone: Option<Zone>,
1219 }
1220 impl GlcPart {
1221 pub fn new(
1222 zone_id: Zid,
1223 lane_number: Option<LanePosition>,
1224 zone_extension: Option<u8>,
1225 zone_heading: Option<HeadingValue>,
1226 zone: Option<Zone>,
1227 ) -> Self {
1228 Self {
1229 zone_id,
1230 lane_number,
1231 zone_extension,
1232 zone_heading,
1233 zone,
1234 }
1235 }
1236 }
1237 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1238 #[rasn(delegate, size("1..=16", extensible))]
1239 pub struct GlcParts(pub SequenceOf<GlcPart>);
1240 #[doc = " new DE in V2"]
1241 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1242 #[rasn(delegate, value("0..=15", extensible))]
1243 pub struct GoodsType(pub Integer);
1244 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1245 #[rasn(choice, automatic_tags)]
1246 pub enum ISO14823Attribute {
1247 dtm(InternationalSignApplicablePeriod),
1248 edt(InternationalSignExemptedApplicablePeriod),
1249 dfl(InternationalSignDirectionalFlowOfLane),
1250 ved(InternationalSignApplicableVehicleDimensions),
1251 spe(InternationalSignSpeedLimits),
1252 roi(InternationalSignRateOfIncline),
1253 dbv(InternationalSignDistanceBetweenVehicles),
1254 ddd(InternationalSignDestinationInformation),
1255 }
1256 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1257 #[rasn(delegate, size("1..=8", extensible))]
1258 pub struct ISO14823Attributes(pub SequenceOf<ISO14823Attribute>);
1259 #[doc = " Inner type "]
1260 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
1261 #[rasn(enumerated)]
1262 #[non_exhaustive]
1263 pub enum ISO14823CodePictogramCodeServiceCategoryCodeTrafficSignPictogram {
1264 dangerWarning = 0,
1265 regulatory = 1,
1266 informative = 2,
1267 }
1268 #[doc = " Inner type "]
1269 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
1270 #[rasn(enumerated)]
1271 #[non_exhaustive]
1272 pub enum ISO14823CodePictogramCodeServiceCategoryCodePublicFacilitiesPictogram {
1273 publicFacilities = 0,
1274 }
1275 #[doc = " Inner type "]
1276 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
1277 #[rasn(enumerated)]
1278 #[non_exhaustive]
1279 pub enum ISO14823CodePictogramCodeServiceCategoryCodeAmbientOrRoadConditionPictogram {
1280 ambientCondition = 0,
1281 roadCondition = 1,
1282 }
1283 #[doc = " Inner type "]
1284 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
1285 #[rasn(enumerated)]
1286 #[non_exhaustive]
1287 pub enum ISO14823CodePictogramCodeServiceCategoryCodeSupplementaryPanel {
1288 supplementaryPanelAndAdditionalPanel = 0,
1289 }
1290 #[doc = " Inner type "]
1291 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1292 #[rasn(choice, automatic_tags)]
1293 #[non_exhaustive]
1294 pub enum ISO14823CodePictogramCodeServiceCategoryCode {
1295 trafficSignPictogram(ISO14823CodePictogramCodeServiceCategoryCodeTrafficSignPictogram),
1296 publicFacilitiesPictogram(
1297 ISO14823CodePictogramCodeServiceCategoryCodePublicFacilitiesPictogram,
1298 ),
1299 ambientOrRoadConditionPictogram(
1300 ISO14823CodePictogramCodeServiceCategoryCodeAmbientOrRoadConditionPictogram,
1301 ),
1302 #[rasn(extension_addition)]
1303 supplementaryPanel(ISO14823CodePictogramCodeServiceCategoryCodeSupplementaryPanel),
1304 }
1305 #[doc = " Inner type "]
1306 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1307 #[rasn(automatic_tags)]
1308 pub struct ISO14823CodePictogramCodePictogramCategoryCode {
1309 #[rasn(value("1..=9"))]
1310 pub nature: u8,
1311 #[rasn(value("0..=99"), identifier = "serialNumber")]
1312 pub serial_number: u8,
1313 }
1314 impl ISO14823CodePictogramCodePictogramCategoryCode {
1315 pub fn new(nature: u8, serial_number: u8) -> Self {
1316 Self {
1317 nature,
1318 serial_number,
1319 }
1320 }
1321 }
1322 #[doc = " Inner type "]
1323 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1324 #[rasn(automatic_tags)]
1325 pub struct ISO14823CodePictogramCode {
1326 #[rasn(size("2"), identifier = "countryCode")]
1327 pub country_code: Option<OctetString>,
1328 #[rasn(identifier = "serviceCategoryCode")]
1329 pub service_category_code: ISO14823CodePictogramCodeServiceCategoryCode,
1330 #[rasn(identifier = "pictogramCategoryCode")]
1331 pub pictogram_category_code: ISO14823CodePictogramCodePictogramCategoryCode,
1332 }
1333 impl ISO14823CodePictogramCode {
1334 pub fn new(
1335 country_code: Option<OctetString>,
1336 service_category_code: ISO14823CodePictogramCodeServiceCategoryCode,
1337 pictogram_category_code: ISO14823CodePictogramCodePictogramCategoryCode,
1338 ) -> Self {
1339 Self {
1340 country_code,
1341 service_category_code,
1342 pictogram_category_code,
1343 }
1344 }
1345 }
1346 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1347 #[rasn(automatic_tags)]
1348 pub struct ISO14823Code {
1349 #[rasn(identifier = "pictogramCode")]
1350 pub pictogram_code: ISO14823CodePictogramCode,
1351 pub attributes: Option<ISO14823Attributes>,
1352 }
1353 impl ISO14823Code {
1354 pub fn new(
1355 pictogram_code: ISO14823CodePictogramCode,
1356 attributes: Option<ISO14823Attributes>,
1357 ) -> Self {
1358 Self {
1359 pictogram_code,
1360 attributes,
1361 }
1362 }
1363 }
1364 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1365 #[rasn(delegate, size("1..=16", extensible))]
1366 pub struct InfrastructureSupportContainer(pub SequenceOf<IscPart>);
1367 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1368 #[rasn(automatic_tags)]
1369 #[non_exhaustive]
1370 pub struct InfrastructureSupportInformation {
1371 #[rasn(identifier = "baseOid")]
1372 pub base_oid: Option<ObjectIdentifier>,
1373 #[rasn(identifier = "supportList")]
1374 pub support_list: SupportItems,
1375 }
1376 impl InfrastructureSupportInformation {
1377 pub fn new(base_oid: Option<ObjectIdentifier>, support_list: SupportItems) -> Self {
1378 Self {
1379 base_oid,
1380 support_list,
1381 }
1382 }
1383 }
1384 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1385 #[rasn(automatic_tags)]
1386 #[non_exhaustive]
1387 pub struct IscPart {
1388 #[rasn(identifier = "detectionZoneIds")]
1389 pub detection_zone_ids: Option<ZoneIds>,
1390 #[rasn(identifier = "relevanceZoneIds")]
1391 pub relevance_zone_ids: ZoneIds,
1392 pub direction: Option<Direction>,
1393 #[rasn(identifier = "infrastructureSupport")]
1394 pub infrastructure_support: InfrastructureSupportInformation,
1395 }
1396 impl IscPart {
1397 pub fn new(
1398 detection_zone_ids: Option<ZoneIds>,
1399 relevance_zone_ids: ZoneIds,
1400 direction: Option<Direction>,
1401 infrastructure_support: InfrastructureSupportInformation,
1402 ) -> Self {
1403 Self {
1404 detection_zone_ids,
1405 relevance_zone_ids,
1406 direction,
1407 infrastructure_support,
1408 }
1409 }
1410 }
1411 #[doc = "size extension in V3.1"]
1412 #[doc = "Definition of Containers"]
1413 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1414 #[rasn(choice, automatic_tags)]
1415 #[non_exhaustive]
1416 pub enum IviContainer {
1417 glc(GeographicLocationContainer),
1418 giv(GeneralIviContainer),
1419 rcc(RoadConfigurationContainer),
1420 tc(TextContainer),
1421 lac(LayoutContainer),
1422 #[rasn(extension_addition)]
1423 avc(AutomatedVehicleContainer),
1424 #[rasn(extension_addition)]
1425 mlc(MapLocationContainer),
1426 #[rasn(extension_addition)]
1427 rsc(RoadSurfaceContainer),
1428 #[rasn(extension_addition)]
1429 isc(InfrastructureSupportContainer),
1430 }
1431 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1432 #[rasn(delegate, size("1..=8", extensible))]
1433 pub struct IviContainers(pub SequenceOf<IviContainer>);
1434 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1435 #[rasn(delegate, value("1..=32767", extensible))]
1436 pub struct IviIdentificationNumber(pub Integer);
1437 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1438 #[rasn(delegate, size("1..=8"))]
1439 pub struct IviIdentificationNumbers(pub SequenceOf<IviIdentificationNumber>);
1440 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1441 #[rasn(automatic_tags)]
1442 #[non_exhaustive]
1443 pub struct IviManagementContainer {
1444 #[rasn(identifier = "serviceProviderId")]
1445 pub service_provider_id: Provider,
1446 #[rasn(identifier = "iviIdentificationNumber")]
1447 pub ivi_identification_number: IviIdentificationNumber,
1448 #[rasn(identifier = "timeStamp")]
1449 pub time_stamp: Option<TimestampIts>,
1450 #[rasn(identifier = "validFrom")]
1451 pub valid_from: Option<TimestampIts>,
1452 #[rasn(identifier = "validTo")]
1453 pub valid_to: Option<TimestampIts>,
1454 #[rasn(identifier = "connectedIviStructures")]
1455 pub connected_ivi_structures: Option<IviIdentificationNumbers>,
1456 #[rasn(identifier = "iviStatus")]
1457 pub ivi_status: IviStatus,
1458 #[rasn(extension_addition, identifier = "connectedDenms")]
1459 pub connected_denms: Option<ActionIdList>,
1460 }
1461 impl IviManagementContainer {
1462 pub fn new(
1463 service_provider_id: Provider,
1464 ivi_identification_number: IviIdentificationNumber,
1465 time_stamp: Option<TimestampIts>,
1466 valid_from: Option<TimestampIts>,
1467 valid_to: Option<TimestampIts>,
1468 connected_ivi_structures: Option<IviIdentificationNumbers>,
1469 ivi_status: IviStatus,
1470 connected_denms: Option<ActionIdList>,
1471 ) -> Self {
1472 Self {
1473 service_provider_id,
1474 ivi_identification_number,
1475 time_stamp,
1476 valid_from,
1477 valid_to,
1478 connected_ivi_structures,
1479 ivi_status,
1480 connected_denms,
1481 }
1482 }
1483 }
1484 #[doc = " extension in V3.1"]
1485 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1486 #[rasn(delegate, value("0..=3"))]
1487 pub struct IviPurpose(pub u8);
1488 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1489 #[rasn(delegate, value("0..=7"))]
1490 pub struct IviStatus(pub u8);
1491 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1492 #[rasn(automatic_tags)]
1493 pub struct IviStructure {
1494 pub mandatory: IviManagementContainer,
1495 pub optional: Option<IviContainers>,
1496 }
1497 impl IviStructure {
1498 pub fn new(mandatory: IviManagementContainer, optional: Option<IviContainers>) -> Self {
1499 Self {
1500 mandatory,
1501 optional,
1502 }
1503 }
1504 }
1505 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1506 #[rasn(delegate, value("0..=7"))]
1507 pub struct IviType(pub u8);
1508 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1509 #[rasn(automatic_tags)]
1510 pub struct LaneCharacteristics {
1511 #[rasn(identifier = "zoneDefinitionAccuracy")]
1512 pub zone_definition_accuracy: DefinitionAccuracy,
1513 #[rasn(identifier = "existinglaneMarkingStatus")]
1514 pub existinglane_marking_status: LaneMarkingStatus,
1515 #[rasn(identifier = "newlaneMarkingColour")]
1516 pub newlane_marking_colour: MarkingColour,
1517 #[rasn(identifier = "laneDelimitationLeft")]
1518 pub lane_delimitation_left: LaneDelimitation,
1519 #[rasn(identifier = "laneDelimitationRight")]
1520 pub lane_delimitation_right: LaneDelimitation,
1521 #[rasn(identifier = "mergingWith")]
1522 pub merging_with: Zid,
1523 }
1524 impl LaneCharacteristics {
1525 pub fn new(
1526 zone_definition_accuracy: DefinitionAccuracy,
1527 existinglane_marking_status: LaneMarkingStatus,
1528 newlane_marking_colour: MarkingColour,
1529 lane_delimitation_left: LaneDelimitation,
1530 lane_delimitation_right: LaneDelimitation,
1531 merging_with: Zid,
1532 ) -> Self {
1533 Self {
1534 zone_definition_accuracy,
1535 existinglane_marking_status,
1536 newlane_marking_colour,
1537 lane_delimitation_left,
1538 lane_delimitation_right,
1539 merging_with,
1540 }
1541 }
1542 }
1543 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1544 #[rasn(delegate, size("1..=16", extensible))]
1545 pub struct LaneConfiguration(pub SequenceOf<LaneInformation>);
1546 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1547 #[rasn(delegate, value("0..=7", extensible))]
1548 pub struct LaneDelimitation(pub Integer);
1549 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1550 #[rasn(delegate, size("1..=16", extensible))]
1551 pub struct LaneIds(pub SequenceOf<Identifier1B>);
1552 #[doc = " Inner type "]
1553 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1554 #[rasn(automatic_tags)]
1555 pub struct LaneInformationExtGroupDetectionZoneIds {
1556 #[rasn(identifier = "detectionZoneIds")]
1557 pub detection_zone_ids: Option<ZoneIds>,
1558 #[rasn(identifier = "relevanceZoneIds")]
1559 pub relevance_zone_ids: Option<ZoneIds>,
1560 #[rasn(identifier = "laneCharacteristics")]
1561 pub lane_characteristics: Option<LaneCharacteristics>,
1562 #[rasn(identifier = "laneSurfaceStaticCharacteristics")]
1563 pub lane_surface_static_characteristics: Option<RoadSurfaceStaticCharacteristics>,
1564 #[rasn(identifier = "laneSurfaceDynamicCharacteristics")]
1565 pub lane_surface_dynamic_characteristics: Option<RoadSurfaceDynamicCharacteristics>,
1566 }
1567 impl LaneInformationExtGroupDetectionZoneIds {
1568 pub fn new(
1569 detection_zone_ids: Option<ZoneIds>,
1570 relevance_zone_ids: Option<ZoneIds>,
1571 lane_characteristics: Option<LaneCharacteristics>,
1572 lane_surface_static_characteristics: Option<RoadSurfaceStaticCharacteristics>,
1573 lane_surface_dynamic_characteristics: Option<RoadSurfaceDynamicCharacteristics>,
1574 ) -> Self {
1575 Self {
1576 detection_zone_ids,
1577 relevance_zone_ids,
1578 lane_characteristics,
1579 lane_surface_static_characteristics,
1580 lane_surface_dynamic_characteristics,
1581 }
1582 }
1583 }
1584 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1585 #[rasn(automatic_tags)]
1586 #[non_exhaustive]
1587 pub struct LaneInformation {
1588 #[rasn(identifier = "laneNumber")]
1589 pub lane_number: LanePosition,
1590 pub direction: Direction,
1591 pub validity: Option<InternationalSignApplicablePeriod>,
1592 #[rasn(identifier = "laneType")]
1593 pub lane_type: LaneType,
1594 #[rasn(identifier = "laneTypeQualifier")]
1595 pub lane_type_qualifier: Option<CompleteVehicleCharacteristics>,
1596 #[rasn(identifier = "laneStatus")]
1597 pub lane_status: LaneStatus,
1598 #[rasn(identifier = "laneWidth")]
1599 pub lane_width: Option<LaneWidth>,
1600 #[rasn(extension_addition_group, identifier = "SEQUENCE")]
1601 pub ext_group_detection_zone_ids: Option<LaneInformationExtGroupDetectionZoneIds>,
1602 }
1603 impl LaneInformation {
1604 pub fn new(
1605 lane_number: LanePosition,
1606 direction: Direction,
1607 validity: Option<InternationalSignApplicablePeriod>,
1608 lane_type: LaneType,
1609 lane_type_qualifier: Option<CompleteVehicleCharacteristics>,
1610 lane_status: LaneStatus,
1611 lane_width: Option<LaneWidth>,
1612 ext_group_detection_zone_ids: Option<LaneInformationExtGroupDetectionZoneIds>,
1613 ) -> Self {
1614 Self {
1615 lane_number,
1616 direction,
1617 validity,
1618 lane_type,
1619 lane_type_qualifier,
1620 lane_status,
1621 lane_width,
1622 ext_group_detection_zone_ids,
1623 }
1624 }
1625 }
1626 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
1627 #[rasn(delegate)]
1628 pub struct LaneMarkingStatus(pub bool);
1629 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1630 #[rasn(delegate, size("1..=8", extensible))]
1631 pub struct LanePositions(pub SequenceOf<LanePosition>);
1632 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1633 #[rasn(delegate, value("0..=7", extensible))]
1634 pub struct LaneStatus(pub Integer);
1635 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1636 #[rasn(automatic_tags)]
1637 pub struct LayoutComponent {
1638 #[rasn(value("1..=8", extensible), identifier = "layoutComponentId")]
1639 pub layout_component_id: Integer,
1640 #[rasn(value("10..=73"))]
1641 pub height: u8,
1642 #[rasn(value("10..=265"))]
1643 pub width: u16,
1644 #[rasn(value("10..=265"))]
1645 pub x: u16,
1646 #[rasn(value("10..=73"))]
1647 pub y: u8,
1648 #[rasn(value("0..=1"), identifier = "textScripting")]
1649 pub text_scripting: u8,
1650 }
1651 impl LayoutComponent {
1652 pub fn new(
1653 layout_component_id: Integer,
1654 height: u8,
1655 width: u16,
1656 x: u16,
1657 y: u8,
1658 text_scripting: u8,
1659 ) -> Self {
1660 Self {
1661 layout_component_id,
1662 height,
1663 width,
1664 x,
1665 y,
1666 text_scripting,
1667 }
1668 }
1669 }
1670 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1671 #[rasn(delegate, size("1..=4", extensible))]
1672 pub struct LayoutComponents(pub SequenceOf<LayoutComponent>);
1673 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1674 #[rasn(automatic_tags)]
1675 #[non_exhaustive]
1676 pub struct LayoutContainer {
1677 #[rasn(value("1..=4", extensible), identifier = "layoutId")]
1678 pub layout_id: Integer,
1679 #[rasn(value("10..=73"))]
1680 pub height: Option<u8>,
1681 #[rasn(value("10..=265"))]
1682 pub width: Option<u16>,
1683 #[rasn(identifier = "layoutComponents")]
1684 pub layout_components: LayoutComponents,
1685 }
1686 impl LayoutContainer {
1687 pub fn new(
1688 layout_id: Integer,
1689 height: Option<u8>,
1690 width: Option<u16>,
1691 layout_components: LayoutComponents,
1692 ) -> Self {
1693 Self {
1694 layout_id,
1695 height,
1696 width,
1697 layout_components,
1698 }
1699 }
1700 }
1701 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1702 #[rasn(automatic_tags)]
1703 pub struct LoadType {
1704 #[rasn(identifier = "goodsType")]
1705 pub goods_type: GoodsType,
1706 #[rasn(identifier = "dangerousGoodsType")]
1707 pub dangerous_goods_type: DangerousGoodsBasic,
1708 #[rasn(identifier = "specialTransportType")]
1709 pub special_transport_type: SpecialTransportType,
1710 }
1711 impl LoadType {
1712 pub fn new(
1713 goods_type: GoodsType,
1714 dangerous_goods_type: DangerousGoodsBasic,
1715 special_transport_type: SpecialTransportType,
1716 ) -> Self {
1717 Self {
1718 goods_type,
1719 dangerous_goods_type,
1720 special_transport_type,
1721 }
1722 }
1723 }
1724 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1725 #[rasn(automatic_tags)]
1726 pub struct MapLocationContainer {
1727 pub reference: MapReference,
1728 pub parts: MlcParts,
1729 }
1730 impl MapLocationContainer {
1731 pub fn new(reference: MapReference, parts: MlcParts) -> Self {
1732 Self { reference, parts }
1733 }
1734 }
1735 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1736 #[rasn(delegate, value("0..=7", extensible))]
1737 pub struct MarkingColour(pub Integer);
1738 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1739 #[rasn(delegate, value("0..=7", extensible))]
1740 pub struct MaterialType(pub Integer);
1741 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1742 #[rasn(delegate, value("1..=64"))]
1743 pub struct MaxLenghtOfPlatoon(pub u8);
1744 #[doc = " new DE in V2"]
1745 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1746 #[rasn(delegate, value("2..=64"))]
1747 pub struct MaxNoOfVehicles(pub u8);
1748 #[doc = " new container part in V2"]
1749 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1750 #[rasn(automatic_tags)]
1751 pub struct MlcPart {
1752 #[rasn(identifier = "zoneId")]
1753 pub zone_id: Zid,
1754 #[rasn(identifier = "laneIds")]
1755 pub lane_ids: Option<LaneIds>,
1756 }
1757 impl MlcPart {
1758 pub fn new(zone_id: Zid, lane_ids: Option<LaneIds>) -> Self {
1759 Self { zone_id, lane_ids }
1760 }
1761 }
1762 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1763 #[rasn(delegate, size("1..=16", extensible))]
1764 pub struct MlcParts(pub SequenceOf<MlcPart>);
1765 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1766 #[rasn(automatic_tags)]
1767 #[non_exhaustive]
1768 pub struct PlatooningRule {
1769 pub priority: PriorityLevel,
1770 #[rasn(identifier = "allowedSaeAutomationLevels")]
1771 pub allowed_sae_automation_levels: SaeAutomationLevels,
1772 #[rasn(identifier = "maxNoOfVehicles")]
1773 pub max_no_of_vehicles: Option<MaxNoOfVehicles>,
1774 #[rasn(identifier = "maxLenghtOfPlatoon")]
1775 pub max_lenght_of_platoon: Option<MaxLenghtOfPlatoon>,
1776 #[rasn(identifier = "minGapBetweenVehicles")]
1777 pub min_gap_between_vehicles: Option<GapBetweenVehicles>,
1778 #[rasn(identifier = "platoonMaxSpeedLimit")]
1779 pub platoon_max_speed_limit: Option<SpeedValue>,
1780 #[rasn(identifier = "platoonMinSpeedLimit")]
1781 pub platoon_min_speed_limit: Option<SpeedValue>,
1782 #[rasn(identifier = "platoonSpeedRecommendation")]
1783 pub platoon_speed_recommendation: Option<SpeedValue>,
1784 #[rasn(identifier = "roadSignCodes")]
1785 pub road_sign_codes: Option<RoadSignCodes>,
1786 #[rasn(identifier = "extraText")]
1787 pub extra_text: Option<ConstraintTextLines2>,
1788 }
1789 impl PlatooningRule {
1790 pub fn new(
1791 priority: PriorityLevel,
1792 allowed_sae_automation_levels: SaeAutomationLevels,
1793 max_no_of_vehicles: Option<MaxNoOfVehicles>,
1794 max_lenght_of_platoon: Option<MaxLenghtOfPlatoon>,
1795 min_gap_between_vehicles: Option<GapBetweenVehicles>,
1796 platoon_max_speed_limit: Option<SpeedValue>,
1797 platoon_min_speed_limit: Option<SpeedValue>,
1798 platoon_speed_recommendation: Option<SpeedValue>,
1799 road_sign_codes: Option<RoadSignCodes>,
1800 extra_text: Option<ConstraintTextLines2>,
1801 ) -> Self {
1802 Self {
1803 priority,
1804 allowed_sae_automation_levels,
1805 max_no_of_vehicles,
1806 max_lenght_of_platoon,
1807 min_gap_between_vehicles,
1808 platoon_max_speed_limit,
1809 platoon_min_speed_limit,
1810 platoon_speed_recommendation,
1811 road_sign_codes,
1812 extra_text,
1813 }
1814 }
1815 }
1816 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1817 #[rasn(delegate, size("1..=5"))]
1818 pub struct PlatooningRules(pub SequenceOf<PlatooningRule>);
1819 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1820 #[rasn(choice, automatic_tags)]
1821 #[non_exhaustive]
1822 pub enum PolygonalLine {
1823 deltaPositions(DeltaPositions),
1824 deltaPositionsWithAltitude(DeltaReferencePositions),
1825 absolutePositions(AbsolutePositions),
1826 absolutePositionsWithAltitude(AbsolutePositionsWAltitude),
1827 }
1828 #[doc = " new DE in V2"]
1829 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1830 #[rasn(delegate, value("0..=2"))]
1831 pub struct PriorityLevel(pub u8);
1832 #[doc = " new DE in V2"]
1833 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1834 #[rasn(delegate, value("0..=15"))]
1835 pub struct RSCUnit(pub u8);
1836 #[doc = " Inner type "]
1837 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1838 #[rasn(choice, automatic_tags)]
1839 #[non_exhaustive]
1840 pub enum RSCodeCode {
1841 viennaConvention(VcCode),
1842 iso14823(ISO14823Code),
1843 #[rasn(value("0..=65535"))]
1844 itisCodes(u16),
1845 anyCatalogue(AnyCatalogue),
1846 }
1847 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1848 #[rasn(automatic_tags)]
1849 pub struct RSCode {
1850 #[rasn(value("1..=4", extensible), identifier = "layoutComponentId")]
1851 pub layout_component_id: Option<Integer>,
1852 pub code: RSCodeCode,
1853 }
1854 impl RSCode {
1855 pub fn new(layout_component_id: Option<Integer>, code: RSCodeCode) -> Self {
1856 Self {
1857 layout_component_id,
1858 code,
1859 }
1860 }
1861 }
1862 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1863 #[rasn(automatic_tags)]
1864 #[non_exhaustive]
1865 pub struct RccPart {
1866 #[rasn(identifier = "relevanceZoneIds")]
1867 pub relevance_zone_ids: ZoneIds,
1868 #[rasn(identifier = "roadType")]
1869 pub road_type: RoadType,
1870 #[rasn(identifier = "laneConfiguration")]
1871 pub lane_configuration: LaneConfiguration,
1872 }
1873 impl RccPart {
1874 pub fn new(
1875 relevance_zone_ids: ZoneIds,
1876 road_type: RoadType,
1877 lane_configuration: LaneConfiguration,
1878 ) -> Self {
1879 Self {
1880 relevance_zone_ids,
1881 road_type,
1882 lane_configuration,
1883 }
1884 }
1885 }
1886 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1887 #[rasn(delegate, size("1..=16", extensible))]
1888 pub struct RoadConfigurationContainer(pub SequenceOf<RccPart>);
1889 #[doc = " new DF in V2"]
1890 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1891 #[rasn(delegate, size("1..=4", extensible))]
1892 pub struct RoadSignCodes(pub SequenceOf<RSCode>);
1893 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1894 #[rasn(delegate, size("1..=16", extensible))]
1895 pub struct RoadSurfaceContainer(pub SequenceOf<RscPart>);
1896 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1897 #[rasn(automatic_tags)]
1898 pub struct RoadSurfaceDynamicCharacteristics {
1899 pub condition: Condition,
1900 pub temperature: Temperature,
1901 #[rasn(identifier = "iceOrWaterDepth")]
1902 pub ice_or_water_depth: Depth,
1903 pub treatment: TreatmentType,
1904 }
1905 impl RoadSurfaceDynamicCharacteristics {
1906 pub fn new(
1907 condition: Condition,
1908 temperature: Temperature,
1909 ice_or_water_depth: Depth,
1910 treatment: TreatmentType,
1911 ) -> Self {
1912 Self {
1913 condition,
1914 temperature,
1915 ice_or_water_depth,
1916 treatment,
1917 }
1918 }
1919 }
1920 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1921 #[rasn(automatic_tags)]
1922 pub struct RoadSurfaceStaticCharacteristics {
1923 #[rasn(identifier = "frictionCoefficient")]
1924 pub friction_coefficient: FrictionCoefficient,
1925 pub material: MaterialType,
1926 pub wear: WearLevel,
1927 #[rasn(identifier = "avBankingAngle")]
1928 pub av_banking_angle: BankingAngle,
1929 }
1930 impl RoadSurfaceStaticCharacteristics {
1931 pub fn new(
1932 friction_coefficient: FrictionCoefficient,
1933 material: MaterialType,
1934 wear: WearLevel,
1935 av_banking_angle: BankingAngle,
1936 ) -> Self {
1937 Self {
1938 friction_coefficient,
1939 material,
1940 wear,
1941 av_banking_angle,
1942 }
1943 }
1944 }
1945 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1946 #[rasn(automatic_tags)]
1947 pub struct RscPart {
1948 #[rasn(identifier = "detectionZoneIds")]
1949 pub detection_zone_ids: Option<ZoneIds>,
1950 #[rasn(identifier = "relevanceZoneIds")]
1951 pub relevance_zone_ids: ZoneIds,
1952 pub direction: Option<Direction>,
1953 #[rasn(identifier = "roadSurfaceStaticCharacteristics")]
1954 pub road_surface_static_characteristics: Option<RoadSurfaceStaticCharacteristics>,
1955 #[rasn(identifier = "roadSurfaceDynamicCharacteristics")]
1956 pub road_surface_dynamic_characteristics: Option<RoadSurfaceDynamicCharacteristics>,
1957 }
1958 impl RscPart {
1959 pub fn new(
1960 detection_zone_ids: Option<ZoneIds>,
1961 relevance_zone_ids: ZoneIds,
1962 direction: Option<Direction>,
1963 road_surface_static_characteristics: Option<RoadSurfaceStaticCharacteristics>,
1964 road_surface_dynamic_characteristics: Option<RoadSurfaceDynamicCharacteristics>,
1965 ) -> Self {
1966 Self {
1967 detection_zone_ids,
1968 relevance_zone_ids,
1969 direction,
1970 road_surface_static_characteristics,
1971 road_surface_dynamic_characteristics,
1972 }
1973 }
1974 }
1975 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1976 #[rasn(delegate, value("0..=5"))]
1977 pub struct SaeAutomationLevel(pub u8);
1978 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1979 #[rasn(delegate, size("1..=5"))]
1980 pub struct SaeAutomationLevels(pub SequenceOf<SaeAutomationLevel>);
1981 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1982 #[rasn(automatic_tags)]
1983 pub struct Segment {
1984 pub line: PolygonalLine,
1985 #[rasn(identifier = "laneWidth")]
1986 pub lane_width: Option<LaneWidth>,
1987 }
1988 impl Segment {
1989 pub fn new(line: PolygonalLine, lane_width: Option<LaneWidth>) -> Self {
1990 Self { line, lane_width }
1991 }
1992 }
1993 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1994 #[rasn(automatic_tags)]
1995 #[non_exhaustive]
1996 pub struct SegmentExtended {
1997 #[rasn(identifier = "segmentReferencePosition")]
1998 pub segment_reference_position: Option<Zid>,
1999 pub line: PolygonalLine,
2000 #[rasn(identifier = "segmentWidthLeft")]
2001 pub segment_width_left: Option<StandardLength9b>,
2002 #[rasn(identifier = "segmentWidthRight")]
2003 pub segment_width_right: Option<StandardLength9b>,
2004 }
2005 impl SegmentExtended {
2006 pub fn new(
2007 segment_reference_position: Option<Zid>,
2008 line: PolygonalLine,
2009 segment_width_left: Option<StandardLength9b>,
2010 segment_width_right: Option<StandardLength9b>,
2011 ) -> Self {
2012 Self {
2013 segment_reference_position,
2014 line,
2015 segment_width_left,
2016 segment_width_right,
2017 }
2018 }
2019 }
2020 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2021 #[rasn(automatic_tags)]
2022 pub struct SupportItem {
2023 pub id: ContentId,
2024 pub content: Any,
2025 }
2026 impl SupportItem {
2027 pub fn new(id: ContentId, content: Any) -> Self {
2028 Self { id, content }
2029 }
2030 }
2031 #[doc = " new DF in V2"]
2032 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2033 #[rasn(delegate, size("1..=128", extensible))]
2034 pub struct SupportItems(pub SequenceOf<SupportItem>);
2035 #[doc = " Inner type "]
2036 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2037 #[rasn(automatic_tags)]
2038 pub struct TcPartExtGroupIviType {
2039 #[rasn(identifier = "iviType")]
2040 pub ivi_type: IviType,
2041 #[rasn(identifier = "laneStatus")]
2042 pub lane_status: Option<LaneStatus>,
2043 #[rasn(identifier = "vehicleCharacteristics")]
2044 pub vehicle_characteristics: Option<VehicleCharacteristicsList>,
2045 }
2046 impl TcPartExtGroupIviType {
2047 pub fn new(
2048 ivi_type: IviType,
2049 lane_status: Option<LaneStatus>,
2050 vehicle_characteristics: Option<VehicleCharacteristicsList>,
2051 ) -> Self {
2052 Self {
2053 ivi_type,
2054 lane_status,
2055 vehicle_characteristics,
2056 }
2057 }
2058 }
2059 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2060 #[rasn(automatic_tags)]
2061 #[non_exhaustive]
2062 pub struct TcPart {
2063 #[rasn(identifier = "detectionZoneIds")]
2064 pub detection_zone_ids: Option<ZoneIds>,
2065 #[rasn(identifier = "relevanceZoneIds")]
2066 pub relevance_zone_ids: ZoneIds,
2067 pub direction: Option<Direction>,
2068 #[rasn(identifier = "driverAwarenessZoneIds")]
2069 pub driver_awareness_zone_ids: Option<ZoneIds>,
2070 #[rasn(value("0..=255"), identifier = "minimumAwarenessTime")]
2071 pub minimum_awareness_time: Option<u8>,
2072 #[rasn(identifier = "applicableLanes")]
2073 pub applicable_lanes: Option<LanePositions>,
2074 #[rasn(value("1..=4", extensible), identifier = "layoutId")]
2075 pub layout_id: Option<Integer>,
2076 #[rasn(value("1..=64", extensible), identifier = "preStoredlayoutId")]
2077 pub pre_storedlayout_id: Option<Integer>,
2078 pub text: Option<TextLines>,
2079 pub data: OctetString,
2080 #[rasn(extension_addition_group, identifier = "SEQUENCE")]
2081 pub ext_group_ivi_type: Option<TcPartExtGroupIviType>,
2082 }
2083 impl TcPart {
2084 pub fn new(
2085 detection_zone_ids: Option<ZoneIds>,
2086 relevance_zone_ids: ZoneIds,
2087 direction: Option<Direction>,
2088 driver_awareness_zone_ids: Option<ZoneIds>,
2089 minimum_awareness_time: Option<u8>,
2090 applicable_lanes: Option<LanePositions>,
2091 layout_id: Option<Integer>,
2092 pre_storedlayout_id: Option<Integer>,
2093 text: Option<TextLines>,
2094 data: OctetString,
2095 ext_group_ivi_type: Option<TcPartExtGroupIviType>,
2096 ) -> Self {
2097 Self {
2098 detection_zone_ids,
2099 relevance_zone_ids,
2100 direction,
2101 driver_awareness_zone_ids,
2102 minimum_awareness_time,
2103 applicable_lanes,
2104 layout_id,
2105 pre_storedlayout_id,
2106 text,
2107 data,
2108 ext_group_ivi_type,
2109 }
2110 }
2111 }
2112 #[doc = " new DE in V2"]
2113 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2114 #[rasn(delegate, value("-100..=151"))]
2115 pub struct Temperature(pub i16);
2116 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2117 #[rasn(automatic_tags)]
2118 pub struct Text {
2119 #[rasn(value("1..=4", extensible), identifier = "layoutComponentId")]
2120 pub layout_component_id: Option<Integer>,
2121 #[rasn(size("10"))]
2122 pub language: BitString,
2123 #[rasn(identifier = "textContent")]
2124 pub text_content: Utf8String,
2125 }
2126 impl Text {
2127 pub fn new(
2128 layout_component_id: Option<Integer>,
2129 language: BitString,
2130 text_content: Utf8String,
2131 ) -> Self {
2132 Self {
2133 layout_component_id,
2134 language,
2135 text_content,
2136 }
2137 }
2138 }
2139 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2140 #[rasn(delegate, size("1..=16", extensible))]
2141 pub struct TextContainer(pub SequenceOf<TcPart>);
2142 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2143 #[rasn(delegate, size("1..=4", extensible))]
2144 pub struct TextLines(pub SequenceOf<Text>);
2145 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2146 #[rasn(automatic_tags)]
2147 pub struct TractorCharacteristics {
2148 #[rasn(identifier = "equalTo")]
2149 pub equal_to: Option<VehicleCharacteristicsFixValuesList>,
2150 #[rasn(identifier = "notEqualTo")]
2151 pub not_equal_to: Option<VehicleCharacteristicsFixValuesList>,
2152 pub ranges: Option<VehicleCharacteristicsRangesList>,
2153 }
2154 impl TractorCharacteristics {
2155 pub fn new(
2156 equal_to: Option<VehicleCharacteristicsFixValuesList>,
2157 not_equal_to: Option<VehicleCharacteristicsFixValuesList>,
2158 ranges: Option<VehicleCharacteristicsRangesList>,
2159 ) -> Self {
2160 Self {
2161 equal_to,
2162 not_equal_to,
2163 ranges,
2164 }
2165 }
2166 }
2167 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2168 #[rasn(automatic_tags)]
2169 pub struct TrailerCharacteristics {
2170 #[rasn(identifier = "equalTo")]
2171 pub equal_to: Option<TrailerCharacteristicsFixValuesList>,
2172 #[rasn(identifier = "notEqualTo")]
2173 pub not_equal_to: Option<TrailerCharacteristicsFixValuesList>,
2174 pub ranges: Option<TrailerCharacteristicsRangesList>,
2175 }
2176 impl TrailerCharacteristics {
2177 pub fn new(
2178 equal_to: Option<TrailerCharacteristicsFixValuesList>,
2179 not_equal_to: Option<TrailerCharacteristicsFixValuesList>,
2180 ranges: Option<TrailerCharacteristicsRangesList>,
2181 ) -> Self {
2182 Self {
2183 equal_to,
2184 not_equal_to,
2185 ranges,
2186 }
2187 }
2188 }
2189 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2190 #[rasn(delegate, size("1..=4", extensible))]
2191 pub struct TrailerCharacteristicsFixValuesList(pub SequenceOf<VehicleCharacteristicsFixValues>);
2192 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2193 #[rasn(delegate, size("1..=3"))]
2194 pub struct TrailerCharacteristicsList(pub SequenceOf<TrailerCharacteristics>);
2195 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2196 #[rasn(delegate, size("1..=4", extensible))]
2197 pub struct TrailerCharacteristicsRangesList(pub SequenceOf<VehicleCharacteristicsRanges>);
2198 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2199 #[rasn(delegate)]
2200 pub struct TrainCharacteristics(pub TractorCharacteristics);
2201 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2202 #[rasn(delegate, value("0..=7"))]
2203 pub struct TreatmentType(pub u8);
2204 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2205 #[rasn(delegate, size("1..=8", extensible))]
2206 pub struct ValidityPeriods(pub SequenceOf<InternationalSignApplicablePeriod>);
2207 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2208 #[rasn(delegate, value("0..=7"))]
2209 pub struct VcClass(pub u8);
2210 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2211 #[rasn(automatic_tags)]
2212 pub struct VcCode {
2213 #[rasn(identifier = "roadSignClass")]
2214 pub road_sign_class: VcClass,
2215 #[rasn(value("1..=64"), identifier = "roadSignCode")]
2216 pub road_sign_code: u8,
2217 #[rasn(identifier = "vcOption")]
2218 pub vc_option: VcOption,
2219 pub validity: Option<ValidityPeriods>,
2220 #[rasn(value("0..=65535"))]
2221 pub value: Option<u16>,
2222 pub unit: Option<RSCUnit>,
2223 }
2224 impl VcCode {
2225 pub fn new(
2226 road_sign_class: VcClass,
2227 road_sign_code: u8,
2228 vc_option: VcOption,
2229 validity: Option<ValidityPeriods>,
2230 value: Option<u16>,
2231 unit: Option<RSCUnit>,
2232 ) -> Self {
2233 Self {
2234 road_sign_class,
2235 road_sign_code,
2236 vc_option,
2237 validity,
2238 value,
2239 unit,
2240 }
2241 }
2242 }
2243 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2244 #[rasn(delegate, value("0..=7"))]
2245 pub struct VcOption(pub u8);
2246 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2247 #[rasn(choice, automatic_tags)]
2248 #[non_exhaustive]
2249 pub enum VehicleCharacteristicsFixValues {
2250 simpleVehicleType(StationType),
2251 euVehicleCategoryCode(EuVehicleCategoryCode),
2252 iso3833VehicleType(Iso3833VehicleType),
2253 euroAndCo2value(EnvironmentalCharacteristics),
2254 engineCharacteristics(EngineCharacteristics),
2255 loadType(LoadType),
2256 usage(VehicleRole),
2257 }
2258 #[doc = " new DF in V3.1"]
2259 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2260 #[rasn(delegate, size("1..=4", extensible))]
2261 pub struct VehicleCharacteristicsFixValuesList(pub SequenceOf<VehicleCharacteristicsFixValues>);
2262 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2263 #[rasn(delegate, size("1..=8", extensible))]
2264 pub struct VehicleCharacteristicsList(pub SequenceOf<CompleteVehicleCharacteristics>);
2265 #[doc = " Inner type "]
2266 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2267 #[rasn(choice, automatic_tags)]
2268 #[non_exhaustive]
2269 pub enum VehicleCharacteristicsRangesLimits {
2270 #[rasn(value("0..=7"))]
2271 numberOfAxles(u8),
2272 vehicleDimensions(VehicleDimensions),
2273 vehicleWeightLimits(VehicleWeightLimits),
2274 axleWeightLimits(AxleWeightLimits),
2275 passengerCapacity(PassengerCapacity),
2276 exhaustEmissionValues(ExhaustEmissionValues),
2277 dieselEmissionValues(DieselEmissionValues),
2278 soundLevel(SoundLevel),
2279 }
2280 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2281 #[rasn(automatic_tags)]
2282 pub struct VehicleCharacteristicsRanges {
2283 #[rasn(identifier = "comparisonOperator")]
2284 pub comparison_operator: ComparisonOperator,
2285 pub limits: VehicleCharacteristicsRangesLimits,
2286 }
2287 impl VehicleCharacteristicsRanges {
2288 pub fn new(
2289 comparison_operator: ComparisonOperator,
2290 limits: VehicleCharacteristicsRangesLimits,
2291 ) -> Self {
2292 Self {
2293 comparison_operator,
2294 limits,
2295 }
2296 }
2297 }
2298 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2299 #[rasn(delegate, size("1..=4", extensible))]
2300 pub struct VehicleCharacteristicsRangesList(pub SequenceOf<VehicleCharacteristicsRanges>);
2301 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2302 #[rasn(delegate, value("0..=7", extensible))]
2303 pub struct WearLevel(pub Integer);
2304 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2305 #[rasn(delegate, value("1..=32", extensible))]
2306 pub struct Zid(pub Integer);
2307 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2308 #[rasn(choice, automatic_tags)]
2309 #[non_exhaustive]
2310 pub enum Zone {
2311 #[rasn(identifier = "segment-carriagewayOrLane")]
2312 segment_carriagewayOrLane(Segment),
2313 area(PolygonalLine),
2314 computedSegment(ComputedSegment),
2315 #[rasn(extension_addition, identifier = "segment-setOfLanes")]
2316 segment_setOfLanes(SegmentExtended),
2317 }
2318 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2319 #[rasn(delegate, size("1..=8", extensible))]
2320 pub struct ZoneIds(pub SequenceOf<Zid>);
2321}
2322#[allow(
2323 non_camel_case_types,
2324 non_snake_case,
2325 non_upper_case_globals,
2326 unused,
2327 clippy::too_many_arguments
2328)]
2329pub mod ivi_is {
2330 extern crate alloc;
2331 use core::borrow::Borrow;
2332
2333 use rasn::prelude::*;
2334
2335 use super::ivi::*;
2336 pub static DUMMY_ID: ContentId = ContentId(Integer::ZERO);
2337 pub static TEST1: ContentId = ContentId(Integer::ONE);
2338}
2339#[allow(
2340 non_camel_case_types,
2341 non_snake_case,
2342 non_upper_case_globals,
2343 unused,
2344 clippy::too_many_arguments
2345)]
2346pub mod ivim_pdu_descriptions {
2347 extern crate alloc;
2348 use core::borrow::Borrow;
2349
2350 use rasn::prelude::*;
2351
2352 use super::super::cdd_2_2_1::etsi_its_cdd::ItsPduHeader;
2353 use super::ivi::IviStructure;
2354
2355 #[doc = "In vehicle information Message Message"]
2356 #[doc = "This DF includes DEs for the IVIM protocolVersion, the IVI message type identifier `messageID`,"]
2357 #[doc = "the station identifier `stationID` of the originating ITS-S and the IVI data from ISO TS 19321."]
2358 #[doc = "- @field header: The DE `protocolVersion` is used to select the appropriate protocol decoder at the receiving ITS-S. "]
2359 #[doc = " It shall be set to 2."]
2360 #[doc = " The DE `messageID` shall be ivim(6)."]
2361 #[doc = "- @field ivi: contains the IVI data as defined in ISO TS 19321."]
2362 #[doc = "\n\n@category: Basic Information"]
2363 #[doc = "\n\n@revision: V1.3.1"]
2364 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
2365 #[rasn(automatic_tags)]
2366 pub struct IVIM {
2367 pub header: ItsPduHeader,
2368 pub ivi: IviStructure,
2369 }
2370 impl IVIM {
2371 pub fn new(header: ItsPduHeader, ivi: IviStructure) -> Self {
2372 Self { header, ivi }
2373 }
2374 }
2375}