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 its_container {
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..=102"))]
15 pub struct AccelerationConfidence(pub u8);
16 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
17 #[rasn(delegate)]
18 pub struct AccelerationControl(pub FixedBitString<7usize>);
19 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
20 #[rasn(delegate, value("0..=255"))]
21 pub struct AccidentSubCauseCode(pub u8);
22 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
23 #[rasn(automatic_tags)]
24 pub struct ActionID {
25 #[rasn(identifier = "originatingStationID")]
26 pub originating_station_id: StationID,
27 #[rasn(identifier = "sequenceNumber")]
28 pub sequence_number: SequenceNumber,
29 }
30 impl ActionID {
31 pub fn new(originating_station_id: StationID, sequence_number: SequenceNumber) -> Self {
32 Self {
33 originating_station_id,
34 sequence_number,
35 }
36 }
37 }
38 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
39 #[rasn(
40 delegate,
41 identifier = "AdverseWeatherCondition-AdhesionSubCauseCode",
42 value("0..=255")
43 )]
44 pub struct AdverseWeatherConditionAdhesionSubCauseCode(pub u8);
45 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
46 #[rasn(
47 delegate,
48 identifier = "AdverseWeatherCondition-ExtremeWeatherConditionSubCauseCode",
49 value("0..=255")
50 )]
51 pub struct AdverseWeatherConditionExtremeWeatherConditionSubCauseCode(pub u8);
52 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
53 #[rasn(
54 delegate,
55 identifier = "AdverseWeatherCondition-PrecipitationSubCauseCode",
56 value("0..=255")
57 )]
58 pub struct AdverseWeatherConditionPrecipitationSubCauseCode(pub u8);
59 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
60 #[rasn(
61 delegate,
62 identifier = "AdverseWeatherCondition-VisibilitySubCauseCode",
63 value("0..=255")
64 )]
65 pub struct AdverseWeatherConditionVisibilitySubCauseCode(pub u8);
66 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
67 #[rasn(automatic_tags)]
68 pub struct Altitude {
69 #[rasn(identifier = "altitudeValue")]
70 pub altitude_value: AltitudeValue,
71 #[rasn(identifier = "altitudeConfidence")]
72 pub altitude_confidence: AltitudeConfidence,
73 }
74 impl Altitude {
75 pub fn new(altitude_value: AltitudeValue, altitude_confidence: AltitudeConfidence) -> Self {
76 Self {
77 altitude_value,
78 altitude_confidence,
79 }
80 }
81 }
82 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
83 #[rasn(enumerated)]
84 pub enum AltitudeConfidence {
85 #[rasn(identifier = "alt-000-01")]
86 alt_000_01 = 0,
87 #[rasn(identifier = "alt-000-02")]
88 alt_000_02 = 1,
89 #[rasn(identifier = "alt-000-05")]
90 alt_000_05 = 2,
91 #[rasn(identifier = "alt-000-10")]
92 alt_000_10 = 3,
93 #[rasn(identifier = "alt-000-20")]
94 alt_000_20 = 4,
95 #[rasn(identifier = "alt-000-50")]
96 alt_000_50 = 5,
97 #[rasn(identifier = "alt-001-00")]
98 alt_001_00 = 6,
99 #[rasn(identifier = "alt-002-00")]
100 alt_002_00 = 7,
101 #[rasn(identifier = "alt-005-00")]
102 alt_005_00 = 8,
103 #[rasn(identifier = "alt-010-00")]
104 alt_010_00 = 9,
105 #[rasn(identifier = "alt-020-00")]
106 alt_020_00 = 10,
107 #[rasn(identifier = "alt-050-00")]
108 alt_050_00 = 11,
109 #[rasn(identifier = "alt-100-00")]
110 alt_100_00 = 12,
111 #[rasn(identifier = "alt-200-00")]
112 alt_200_00 = 13,
113 outOfRange = 14,
114 unavailable = 15,
115 }
116 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
117 #[rasn(delegate, value("-100000..=800001"))]
118 pub struct AltitudeValue(pub i32);
119 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
120 #[rasn(automatic_tags)]
121 #[non_exhaustive]
122 pub struct CauseCode {
123 #[rasn(identifier = "causeCode")]
124 pub cause_code: CauseCodeType,
125 #[rasn(identifier = "subCauseCode")]
126 pub sub_cause_code: SubCauseCodeType,
127 }
128 impl CauseCode {
129 pub fn new(cause_code: CauseCodeType, sub_cause_code: SubCauseCodeType) -> Self {
130 Self {
131 cause_code,
132 sub_cause_code,
133 }
134 }
135 }
136 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
137 #[rasn(delegate, value("0..=255"))]
138 pub struct CauseCodeType(pub u8);
139 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
140 #[rasn(automatic_tags)]
141 #[non_exhaustive]
142 pub struct CenDsrcTollingZone {
143 #[rasn(identifier = "protectedZoneLatitude")]
144 pub protected_zone_latitude: Latitude,
145 #[rasn(identifier = "protectedZoneLongitude")]
146 pub protected_zone_longitude: Longitude,
147 #[rasn(identifier = "cenDsrcTollingZoneID")]
148 pub cen_dsrc_tolling_zone_id: Option<CenDsrcTollingZoneID>,
149 }
150 impl CenDsrcTollingZone {
151 pub fn new(
152 protected_zone_latitude: Latitude,
153 protected_zone_longitude: Longitude,
154 cen_dsrc_tolling_zone_id: Option<CenDsrcTollingZoneID>,
155 ) -> Self {
156 Self {
157 protected_zone_latitude,
158 protected_zone_longitude,
159 cen_dsrc_tolling_zone_id,
160 }
161 }
162 }
163 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
164 #[rasn(delegate)]
165 pub struct CenDsrcTollingZoneID(pub ProtectedZoneID);
166 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
167 #[rasn(automatic_tags)]
168 #[non_exhaustive]
169 pub struct ClosedLanes {
170 #[rasn(identifier = "innerhardShoulderStatus")]
171 pub innerhard_shoulder_status: Option<HardShoulderStatus>,
172 #[rasn(identifier = "outerhardShoulderStatus")]
173 pub outerhard_shoulder_status: Option<HardShoulderStatus>,
174 #[rasn(identifier = "drivingLaneStatus")]
175 pub driving_lane_status: Option<DrivingLaneStatus>,
176 }
177 impl ClosedLanes {
178 pub fn new(
179 innerhard_shoulder_status: Option<HardShoulderStatus>,
180 outerhard_shoulder_status: Option<HardShoulderStatus>,
181 driving_lane_status: Option<DrivingLaneStatus>,
182 ) -> Self {
183 Self {
184 innerhard_shoulder_status,
185 outerhard_shoulder_status,
186 driving_lane_status,
187 }
188 }
189 }
190 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
191 #[rasn(delegate, value("0..=255"))]
192 pub struct CollisionRiskSubCauseCode(pub u8);
193 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
194 #[rasn(automatic_tags)]
195 pub struct Curvature {
196 #[rasn(identifier = "curvatureValue")]
197 pub curvature_value: CurvatureValue,
198 #[rasn(identifier = "curvatureConfidence")]
199 pub curvature_confidence: CurvatureConfidence,
200 }
201 impl Curvature {
202 pub fn new(
203 curvature_value: CurvatureValue,
204 curvature_confidence: CurvatureConfidence,
205 ) -> Self {
206 Self {
207 curvature_value,
208 curvature_confidence,
209 }
210 }
211 }
212 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
213 #[rasn(enumerated)]
214 #[non_exhaustive]
215 pub enum CurvatureCalculationMode {
216 yawRateUsed = 0,
217 yawRateNotUsed = 1,
218 unavailable = 2,
219 }
220 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
221 #[rasn(enumerated)]
222 pub enum CurvatureConfidence {
223 #[rasn(identifier = "onePerMeter-0-00002")]
224 onePerMeter_0_00002 = 0,
225 #[rasn(identifier = "onePerMeter-0-0001")]
226 onePerMeter_0_0001 = 1,
227 #[rasn(identifier = "onePerMeter-0-0005")]
228 onePerMeter_0_0005 = 2,
229 #[rasn(identifier = "onePerMeter-0-002")]
230 onePerMeter_0_002 = 3,
231 #[rasn(identifier = "onePerMeter-0-01")]
232 onePerMeter_0_01 = 4,
233 #[rasn(identifier = "onePerMeter-0-1")]
234 onePerMeter_0_1 = 5,
235 outOfRange = 6,
236 unavailable = 7,
237 }
238 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
239 #[rasn(delegate, value("-1023..=1023"))]
240 pub struct CurvatureValue(pub i16);
241 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
242 #[rasn(delegate, value("0..=255"))]
243 pub struct DangerousEndOfQueueSubCauseCode(pub u8);
244 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
245 #[rasn(enumerated)]
246 pub enum DangerousGoodsBasic {
247 explosives1 = 0,
248 explosives2 = 1,
249 explosives3 = 2,
250 explosives4 = 3,
251 explosives5 = 4,
252 explosives6 = 5,
253 flammableGases = 6,
254 nonFlammableGases = 7,
255 toxicGases = 8,
256 flammableLiquids = 9,
257 flammableSolids = 10,
258 substancesLiableToSpontaneousCombustion = 11,
259 substancesEmittingFlammableGasesUponContactWithWater = 12,
260 oxidizingSubstances = 13,
261 organicPeroxides = 14,
262 toxicSubstances = 15,
263 infectiousSubstances = 16,
264 radioactiveMaterial = 17,
265 corrosiveSubstances = 18,
266 miscellaneousDangerousSubstances = 19,
267 }
268 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
269 #[rasn(automatic_tags)]
270 #[non_exhaustive]
271 pub struct DangerousGoodsExtended {
272 #[rasn(identifier = "dangerousGoodsType")]
273 pub dangerous_goods_type: DangerousGoodsBasic,
274 #[rasn(value("0..=9999"), identifier = "unNumber")]
275 pub un_number: u16,
276 #[rasn(identifier = "elevatedTemperature")]
277 pub elevated_temperature: bool,
278 #[rasn(identifier = "tunnelsRestricted")]
279 pub tunnels_restricted: bool,
280 #[rasn(identifier = "limitedQuantity")]
281 pub limited_quantity: bool,
282 #[rasn(size("1..=24"), identifier = "emergencyActionCode")]
283 pub emergency_action_code: Option<Ia5String>,
284 #[rasn(identifier = "phoneNumber")]
285 pub phone_number: Option<PhoneNumber>,
286 #[rasn(identifier = "companyName")]
287 pub company_name: Option<Utf8String>,
288 }
289 impl DangerousGoodsExtended {
290 pub fn new(
291 dangerous_goods_type: DangerousGoodsBasic,
292 un_number: u16,
293 elevated_temperature: bool,
294 tunnels_restricted: bool,
295 limited_quantity: bool,
296 emergency_action_code: Option<Ia5String>,
297 phone_number: Option<PhoneNumber>,
298 company_name: Option<Utf8String>,
299 ) -> Self {
300 Self {
301 dangerous_goods_type,
302 un_number,
303 elevated_temperature,
304 tunnels_restricted,
305 limited_quantity,
306 emergency_action_code,
307 phone_number,
308 company_name,
309 }
310 }
311 }
312 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
313 #[rasn(delegate, value("0..=255"))]
314 pub struct DangerousSituationSubCauseCode(pub u8);
315 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
316 #[rasn(delegate, value("-12700..=12800"))]
317 pub struct DeltaAltitude(pub i16);
318 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
319 #[rasn(delegate, value("-131071..=131072"))]
320 pub struct DeltaLatitude(pub i32);
321 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
322 #[rasn(delegate, value("-131071..=131072"))]
323 pub struct DeltaLongitude(pub i32);
324 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
325 #[rasn(automatic_tags)]
326 pub struct DeltaReferencePosition {
327 #[rasn(identifier = "deltaLatitude")]
328 pub delta_latitude: DeltaLatitude,
329 #[rasn(identifier = "deltaLongitude")]
330 pub delta_longitude: DeltaLongitude,
331 #[rasn(identifier = "deltaAltitude")]
332 pub delta_altitude: DeltaAltitude,
333 }
334 impl DeltaReferencePosition {
335 pub fn new(
336 delta_latitude: DeltaLatitude,
337 delta_longitude: DeltaLongitude,
338 delta_altitude: DeltaAltitude,
339 ) -> Self {
340 Self {
341 delta_latitude,
342 delta_longitude,
343 delta_altitude,
344 }
345 }
346 }
347 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
348 #[rasn(delegate, size("1..=256"))]
349 pub struct DigitalMap(pub SequenceOf<ReferencePosition>);
350 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
351 #[rasn(enumerated)]
352 pub enum DriveDirection {
353 forward = 0,
354 backward = 1,
355 unavailable = 2,
356 }
357 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
358 #[rasn(delegate, size("1..=13"))]
359 pub struct DrivingLaneStatus(pub BitString);
360 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
361 #[rasn(delegate)]
362 pub struct EmbarkationStatus(pub bool);
363 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
364 #[rasn(delegate)]
365 pub struct EmergencyPriority(pub FixedBitString<2usize>);
366 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
367 #[rasn(delegate, value("0..=255"))]
368 pub struct EmergencyVehicleApproachingSubCauseCode(pub u8);
369 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
370 #[rasn(delegate)]
371 pub struct EnergyStorageType(pub FixedBitString<7usize>);
372 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
373 #[rasn(delegate, size("1..=23"))]
374 pub struct EventHistory(pub SequenceOf<EventPoint>);
375 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
376 #[rasn(automatic_tags)]
377 pub struct EventPoint {
378 #[rasn(identifier = "eventPosition")]
379 pub event_position: DeltaReferencePosition,
380 #[rasn(identifier = "eventDeltaTime")]
381 pub event_delta_time: Option<PathDeltaTime>,
382 #[rasn(identifier = "informationQuality")]
383 pub information_quality: InformationQuality,
384 }
385 impl EventPoint {
386 pub fn new(
387 event_position: DeltaReferencePosition,
388 event_delta_time: Option<PathDeltaTime>,
389 information_quality: InformationQuality,
390 ) -> Self {
391 Self {
392 event_position,
393 event_delta_time,
394 information_quality,
395 }
396 }
397 }
398 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
399 #[rasn(delegate)]
400 pub struct ExteriorLights(pub FixedBitString<8usize>);
401 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
402 #[rasn(enumerated)]
403 pub enum HardShoulderStatus {
404 availableForStopping = 0,
405 closed = 1,
406 availableForDriving = 2,
407 }
408 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
409 #[rasn(
410 delegate,
411 identifier = "HazardousLocation-AnimalOnTheRoadSubCauseCode",
412 value("0..=255")
413 )]
414 pub struct HazardousLocationAnimalOnTheRoadSubCauseCode(pub u8);
415 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
416 #[rasn(
417 delegate,
418 identifier = "HazardousLocation-DangerousCurveSubCauseCode",
419 value("0..=255")
420 )]
421 pub struct HazardousLocationDangerousCurveSubCauseCode(pub u8);
422 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
423 #[rasn(
424 delegate,
425 identifier = "HazardousLocation-ObstacleOnTheRoadSubCauseCode",
426 value("0..=255")
427 )]
428 pub struct HazardousLocationObstacleOnTheRoadSubCauseCode(pub u8);
429 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
430 #[rasn(
431 delegate,
432 identifier = "HazardousLocation-SurfaceConditionSubCauseCode",
433 value("0..=255")
434 )]
435 pub struct HazardousLocationSurfaceConditionSubCauseCode(pub u8);
436 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
437 #[rasn(automatic_tags)]
438 pub struct Heading {
439 #[rasn(identifier = "headingValue")]
440 pub heading_value: HeadingValue,
441 #[rasn(identifier = "headingConfidence")]
442 pub heading_confidence: HeadingConfidence,
443 }
444 impl Heading {
445 pub fn new(heading_value: HeadingValue, heading_confidence: HeadingConfidence) -> Self {
446 Self {
447 heading_value,
448 heading_confidence,
449 }
450 }
451 }
452 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
453 #[rasn(delegate, value("1..=127"))]
454 pub struct HeadingConfidence(pub u8);
455 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
456 #[rasn(delegate, value("0..=3601"))]
457 pub struct HeadingValue(pub u16);
458 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
459 #[rasn(delegate, value("1..=100"))]
460 pub struct HeightLonCarr(pub u8);
461 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
462 #[rasn(delegate, value("0..=255"))]
463 pub struct HumanPresenceOnTheRoadSubCauseCode(pub u8);
464 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
465 #[rasn(delegate, value("0..=255"))]
466 pub struct HumanProblemSubCauseCode(pub u8);
467 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
468 #[rasn(delegate, value("0..=7"))]
469 pub struct InformationQuality(pub u8);
470 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
471 #[rasn(delegate, size("1..=40"))]
472 pub struct ItineraryPath(pub SequenceOf<ReferencePosition>);
473 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
474 #[rasn(automatic_tags)]
475 pub struct ItsPduHeader {
476 #[rasn(value("0..=255"), identifier = "protocolVersion")]
477 pub protocol_version: u8,
478 #[rasn(value("0..=255"), identifier = "messageID")]
479 pub message_id: u8,
480 #[rasn(identifier = "stationID")]
481 pub station_id: StationID,
482 }
483 impl ItsPduHeader {
484 pub fn new(protocol_version: u8, message_id: u8, station_id: StationID) -> Self {
485 Self {
486 protocol_version,
487 message_id,
488 station_id,
489 }
490 }
491 }
492 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
493 #[rasn(delegate, value("-1..=14"))]
494 pub struct LanePosition(pub i8);
495 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
496 #[rasn(automatic_tags)]
497 pub struct LateralAcceleration {
498 #[rasn(identifier = "lateralAccelerationValue")]
499 pub lateral_acceleration_value: LateralAccelerationValue,
500 #[rasn(identifier = "lateralAccelerationConfidence")]
501 pub lateral_acceleration_confidence: AccelerationConfidence,
502 }
503 impl LateralAcceleration {
504 pub fn new(
505 lateral_acceleration_value: LateralAccelerationValue,
506 lateral_acceleration_confidence: AccelerationConfidence,
507 ) -> Self {
508 Self {
509 lateral_acceleration_value,
510 lateral_acceleration_confidence,
511 }
512 }
513 }
514 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
515 #[rasn(delegate, value("-160..=161"))]
516 pub struct LateralAccelerationValue(pub i16);
517 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
518 #[rasn(delegate, value("-900000000..=900000001"))]
519 pub struct Latitude(pub i32);
520 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
521 #[rasn(delegate)]
522 pub struct LightBarSirenInUse(pub FixedBitString<2usize>);
523 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
524 #[rasn(delegate, value("-1800000000..=1800000001"))]
525 pub struct Longitude(pub i32);
526 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
527 #[rasn(automatic_tags)]
528 pub struct LongitudinalAcceleration {
529 #[rasn(identifier = "longitudinalAccelerationValue")]
530 pub longitudinal_acceleration_value: LongitudinalAccelerationValue,
531 #[rasn(identifier = "longitudinalAccelerationConfidence")]
532 pub longitudinal_acceleration_confidence: AccelerationConfidence,
533 }
534 impl LongitudinalAcceleration {
535 pub fn new(
536 longitudinal_acceleration_value: LongitudinalAccelerationValue,
537 longitudinal_acceleration_confidence: AccelerationConfidence,
538 ) -> Self {
539 Self {
540 longitudinal_acceleration_value,
541 longitudinal_acceleration_confidence,
542 }
543 }
544 }
545 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
546 #[rasn(delegate, value("-160..=161"))]
547 pub struct LongitudinalAccelerationValue(pub i16);
548 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
549 #[rasn(delegate, value("0..=127"))]
550 pub struct NumberOfOccupants(pub u8);
551 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
552 #[rasn(delegate)]
553 pub struct OpeningDaysHours(pub Utf8String);
554 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
555 #[rasn(delegate, value("1..=65535", extensible))]
556 pub struct PathDeltaTime(pub Integer);
557 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
558 #[rasn(delegate, size("0..=40"))]
559 pub struct PathHistory(pub SequenceOf<PathPoint>);
560 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
561 #[rasn(automatic_tags)]
562 pub struct PathPoint {
563 #[rasn(identifier = "pathPosition")]
564 pub path_position: DeltaReferencePosition,
565 #[rasn(identifier = "pathDeltaTime")]
566 pub path_delta_time: Option<PathDeltaTime>,
567 }
568 impl PathPoint {
569 pub fn new(
570 path_position: DeltaReferencePosition,
571 path_delta_time: Option<PathDeltaTime>,
572 ) -> Self {
573 Self {
574 path_position,
575 path_delta_time,
576 }
577 }
578 }
579 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
580 #[rasn(delegate, value("0..=7"))]
581 pub struct PerformanceClass(pub u8);
582 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
583 #[rasn(delegate, size("1..=16"))]
584 pub struct PhoneNumber(pub NumericString);
585 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
586 #[rasn(delegate, value("1..=63"))]
587 pub struct PosCentMass(pub u8);
588 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
589 #[rasn(automatic_tags)]
590 pub struct PosConfidenceEllipse {
591 #[rasn(identifier = "semiMajorConfidence")]
592 pub semi_major_confidence: SemiAxisLength,
593 #[rasn(identifier = "semiMinorConfidence")]
594 pub semi_minor_confidence: SemiAxisLength,
595 #[rasn(identifier = "semiMajorOrientation")]
596 pub semi_major_orientation: HeadingValue,
597 }
598 impl PosConfidenceEllipse {
599 pub fn new(
600 semi_major_confidence: SemiAxisLength,
601 semi_minor_confidence: SemiAxisLength,
602 semi_major_orientation: HeadingValue,
603 ) -> Self {
604 Self {
605 semi_major_confidence,
606 semi_minor_confidence,
607 semi_major_orientation,
608 }
609 }
610 }
611 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
612 #[rasn(delegate, value("1..=20"))]
613 pub struct PosFrontAx(pub u8);
614 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
615 #[rasn(delegate, value("1..=127"))]
616 pub struct PosLonCarr(pub u8);
617 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
618 #[rasn(delegate, value("1..=30"))]
619 pub struct PosPillar(pub u8);
620 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
621 #[rasn(delegate)]
622 pub struct PositionOfOccupants(pub FixedBitString<20usize>);
623 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
624 #[rasn(delegate, size("1..=3", extensible))]
625 pub struct PositionOfPillars(pub SequenceOf<PosPillar>);
626 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
627 #[rasn(enumerated)]
628 #[non_exhaustive]
629 pub enum PositioningSolutionType {
630 noPositioningSolution = 0,
631 sGNSS = 1,
632 dGNSS = 2,
633 sGNSSplusDR = 3,
634 dGNSSplusDR = 4,
635 dR = 5,
636 }
637 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
638 #[rasn(delegate, value("0..=255"))]
639 pub struct PostCrashSubCauseCode(pub u8);
640 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
641 #[rasn(automatic_tags)]
642 #[non_exhaustive]
643 pub struct ProtectedCommunicationZone {
644 #[rasn(identifier = "protectedZoneType")]
645 pub protected_zone_type: ProtectedZoneType,
646 #[rasn(identifier = "expiryTime")]
647 pub expiry_time: Option<TimestampIts>,
648 #[rasn(identifier = "protectedZoneLatitude")]
649 pub protected_zone_latitude: Latitude,
650 #[rasn(identifier = "protectedZoneLongitude")]
651 pub protected_zone_longitude: Longitude,
652 #[rasn(identifier = "protectedZoneRadius")]
653 pub protected_zone_radius: Option<ProtectedZoneRadius>,
654 #[rasn(identifier = "protectedZoneID")]
655 pub protected_zone_id: Option<ProtectedZoneID>,
656 }
657 impl ProtectedCommunicationZone {
658 pub fn new(
659 protected_zone_type: ProtectedZoneType,
660 expiry_time: Option<TimestampIts>,
661 protected_zone_latitude: Latitude,
662 protected_zone_longitude: Longitude,
663 protected_zone_radius: Option<ProtectedZoneRadius>,
664 protected_zone_id: Option<ProtectedZoneID>,
665 ) -> Self {
666 Self {
667 protected_zone_type,
668 expiry_time,
669 protected_zone_latitude,
670 protected_zone_longitude,
671 protected_zone_radius,
672 protected_zone_id,
673 }
674 }
675 }
676 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
677 #[rasn(delegate, size("1..=16"))]
678 pub struct ProtectedCommunicationZonesRSU(pub SequenceOf<ProtectedCommunicationZone>);
679 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
680 #[rasn(delegate, value("0..=134217727"))]
681 pub struct ProtectedZoneID(pub u32);
682 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
683 #[rasn(delegate, value("1..=255", extensible))]
684 pub struct ProtectedZoneRadius(pub Integer);
685 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
686 #[rasn(enumerated)]
687 #[non_exhaustive]
688 pub enum ProtectedZoneType {
689 permanentCenDsrcTolling = 0,
690 #[rasn(extension_addition)]
691 temporaryCenDsrcTolling = 1,
692 }
693 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
694 #[rasn(automatic_tags)]
695 pub struct PtActivation {
696 #[rasn(identifier = "ptActivationType")]
697 pub pt_activation_type: PtActivationType,
698 #[rasn(identifier = "ptActivationData")]
699 pub pt_activation_data: PtActivationData,
700 }
701 impl PtActivation {
702 pub fn new(
703 pt_activation_type: PtActivationType,
704 pt_activation_data: PtActivationData,
705 ) -> Self {
706 Self {
707 pt_activation_type,
708 pt_activation_data,
709 }
710 }
711 }
712 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
713 #[rasn(delegate, size("1..=20"))]
714 pub struct PtActivationData(pub OctetString);
715 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
716 #[rasn(delegate, value("0..=255"))]
717 pub struct PtActivationType(pub u8);
718 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
719 #[rasn(automatic_tags)]
720 pub struct ReferencePosition {
721 pub latitude: Latitude,
722 pub longitude: Longitude,
723 #[rasn(identifier = "positionConfidenceEllipse")]
724 pub position_confidence_ellipse: PosConfidenceEllipse,
725 pub altitude: Altitude,
726 }
727 impl ReferencePosition {
728 pub fn new(
729 latitude: Latitude,
730 longitude: Longitude,
731 position_confidence_ellipse: PosConfidenceEllipse,
732 altitude: Altitude,
733 ) -> Self {
734 Self {
735 latitude,
736 longitude,
737 position_confidence_ellipse,
738 altitude,
739 }
740 }
741 }
742 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
743 #[rasn(enumerated)]
744 pub enum RelevanceDistance {
745 lessThan50m = 0,
746 lessThan100m = 1,
747 lessThan200m = 2,
748 lessThan500m = 3,
749 lessThan1000m = 4,
750 lessThan5km = 5,
751 lessThan10km = 6,
752 over10km = 7,
753 }
754 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
755 #[rasn(enumerated)]
756 pub enum RelevanceTrafficDirection {
757 allTrafficDirections = 0,
758 upstreamTraffic = 1,
759 downstreamTraffic = 2,
760 oppositeTraffic = 3,
761 }
762 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
763 #[rasn(enumerated)]
764 pub enum RequestResponseIndication {
765 request = 0,
766 response = 1,
767 }
768 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
769 #[rasn(delegate, value("0..=255"))]
770 pub struct RescueAndRecoveryWorkInProgressSubCauseCode(pub u8);
771 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
772 #[rasn(delegate, size("1..=3", extensible))]
773 pub struct RestrictedTypes(pub SequenceOf<StationType>);
774 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
775 #[rasn(enumerated)]
776 pub enum RoadType {
777 #[rasn(identifier = "urban-NoStructuralSeparationToOppositeLanes")]
778 urban_NoStructuralSeparationToOppositeLanes = 0,
779 #[rasn(identifier = "urban-WithStructuralSeparationToOppositeLanes")]
780 urban_WithStructuralSeparationToOppositeLanes = 1,
781 #[rasn(identifier = "nonUrban-NoStructuralSeparationToOppositeLanes")]
782 nonUrban_NoStructuralSeparationToOppositeLanes = 2,
783 #[rasn(identifier = "nonUrban-WithStructuralSeparationToOppositeLanes")]
784 nonUrban_WithStructuralSeparationToOppositeLanes = 3,
785 }
786 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
787 #[rasn(delegate, value("0..=255"))]
788 pub struct RoadworksSubCauseCode(pub u8);
789 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
790 #[rasn(delegate, value("0..=4095"))]
791 pub struct SemiAxisLength(pub u16);
792 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
793 #[rasn(delegate, value("0..=65535"))]
794 pub struct SequenceNumber(pub u16);
795 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
796 #[rasn(delegate, value("0..=255"))]
797 pub struct SignalViolationSubCauseCode(pub u8);
798 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
799 #[rasn(delegate, value("0..=255"))]
800 pub struct SlowVehicleSubCauseCode(pub u8);
801 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
802 #[rasn(delegate)]
803 pub struct SpecialTransportType(pub FixedBitString<4usize>);
804 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
805 #[rasn(automatic_tags)]
806 pub struct Speed {
807 #[rasn(identifier = "speedValue")]
808 pub speed_value: SpeedValue,
809 #[rasn(identifier = "speedConfidence")]
810 pub speed_confidence: SpeedConfidence,
811 }
812 impl Speed {
813 pub fn new(speed_value: SpeedValue, speed_confidence: SpeedConfidence) -> Self {
814 Self {
815 speed_value,
816 speed_confidence,
817 }
818 }
819 }
820 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
821 #[rasn(delegate, value("1..=127"))]
822 pub struct SpeedConfidence(pub u8);
823 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
824 #[rasn(delegate, value("1..=255"))]
825 pub struct SpeedLimit(pub u8);
826 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
827 #[rasn(delegate, value("0..=16383"))]
828 pub struct SpeedValue(pub u16);
829 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
830 #[rasn(delegate, value("0..=4294967295"))]
831 pub struct StationID(pub u32);
832 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
833 #[rasn(delegate, value("0..=255"))]
834 pub struct StationType(pub u8);
835 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
836 #[rasn(enumerated)]
837 pub enum StationarySince {
838 lessThan1Minute = 0,
839 lessThan2Minutes = 1,
840 lessThan15Minutes = 2,
841 equalOrGreater15Minutes = 3,
842 }
843 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
844 #[rasn(delegate, value("0..=255"))]
845 pub struct StationaryVehicleSubCauseCode(pub u8);
846 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
847 #[rasn(automatic_tags)]
848 pub struct SteeringWheelAngle {
849 #[rasn(identifier = "steeringWheelAngleValue")]
850 pub steering_wheel_angle_value: SteeringWheelAngleValue,
851 #[rasn(identifier = "steeringWheelAngleConfidence")]
852 pub steering_wheel_angle_confidence: SteeringWheelAngleConfidence,
853 }
854 impl SteeringWheelAngle {
855 pub fn new(
856 steering_wheel_angle_value: SteeringWheelAngleValue,
857 steering_wheel_angle_confidence: SteeringWheelAngleConfidence,
858 ) -> Self {
859 Self {
860 steering_wheel_angle_value,
861 steering_wheel_angle_confidence,
862 }
863 }
864 }
865 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
866 #[rasn(delegate, value("1..=127"))]
867 pub struct SteeringWheelAngleConfidence(pub u8);
868 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
869 #[rasn(delegate, value("-511..=512"))]
870 pub struct SteeringWheelAngleValue(pub i16);
871 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
872 #[rasn(delegate, value("0..=255"))]
873 pub struct SubCauseCodeType(pub u8);
874 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
875 #[rasn(delegate, value("-60..=67"))]
876 pub struct Temperature(pub i8);
877 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
878 #[rasn(delegate, value("0..=4398046511103"))]
879 pub struct TimestampIts(pub u64);
880 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
881 #[rasn(delegate, size("1..=7"))]
882 pub struct Traces(pub SequenceOf<PathHistory>);
883 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
884 #[rasn(delegate, value("0..=255"))]
885 pub struct TrafficConditionSubCauseCode(pub u8);
886 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
887 #[rasn(enumerated)]
888 #[non_exhaustive]
889 pub enum TrafficRule {
890 noPassing = 0,
891 noPassingForTrucks = 1,
892 passToRight = 2,
893 passToLeft = 3,
894 }
895 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
896 #[rasn(delegate, value("1..=10000"))]
897 pub struct TransmissionInterval(pub u16);
898 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
899 #[rasn(delegate, value("1..=255"))]
900 pub struct TurningRadius(pub u8);
901 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
902 #[rasn(delegate, size("6"))]
903 pub struct VDS(pub Ia5String);
904 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
905 #[rasn(delegate, value("0..=86400"))]
906 pub struct ValidityDuration(pub u32);
907 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
908 #[rasn(delegate, value("0..=255"))]
909 pub struct VehicleBreakdownSubCauseCode(pub u8);
910 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
911 #[rasn(automatic_tags)]
912 #[non_exhaustive]
913 pub struct VehicleIdentification {
914 #[rasn(identifier = "wMInumber")]
915 pub w_minumber: Option<WMInumber>,
916 #[rasn(identifier = "vDS")]
917 pub v_ds: Option<VDS>,
918 }
919 impl VehicleIdentification {
920 pub fn new(w_minumber: Option<WMInumber>, v_ds: Option<VDS>) -> Self {
921 Self { w_minumber, v_ds }
922 }
923 }
924 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
925 #[rasn(automatic_tags)]
926 pub struct VehicleLength {
927 #[rasn(identifier = "vehicleLengthValue")]
928 pub vehicle_length_value: VehicleLengthValue,
929 #[rasn(identifier = "vehicleLengthConfidenceIndication")]
930 pub vehicle_length_confidence_indication: VehicleLengthConfidenceIndication,
931 }
932 impl VehicleLength {
933 pub fn new(
934 vehicle_length_value: VehicleLengthValue,
935 vehicle_length_confidence_indication: VehicleLengthConfidenceIndication,
936 ) -> Self {
937 Self {
938 vehicle_length_value,
939 vehicle_length_confidence_indication,
940 }
941 }
942 }
943 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
944 #[rasn(enumerated)]
945 pub enum VehicleLengthConfidenceIndication {
946 noTrailerPresent = 0,
947 trailerPresentWithKnownLength = 1,
948 trailerPresentWithUnknownLength = 2,
949 trailerPresenceIsUnknown = 3,
950 unavailable = 4,
951 }
952 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
953 #[rasn(delegate, value("1..=1023"))]
954 pub struct VehicleLengthValue(pub u16);
955 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
956 #[rasn(delegate, value("1..=1024"))]
957 pub struct VehicleMass(pub u16);
958 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
959 #[rasn(enumerated)]
960 pub enum VehicleRole {
961 default = 0,
962 publicTransport = 1,
963 specialTransport = 2,
964 dangerousGoods = 3,
965 roadWork = 4,
966 rescue = 5,
967 emergency = 6,
968 safetyCar = 7,
969 agriculture = 8,
970 commercial = 9,
971 military = 10,
972 roadOperator = 11,
973 taxi = 12,
974 reserved1 = 13,
975 reserved2 = 14,
976 reserved3 = 15,
977 }
978 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
979 #[rasn(delegate, value("1..=62"))]
980 pub struct VehicleWidth(pub u8);
981 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
982 #[rasn(automatic_tags)]
983 pub struct VerticalAcceleration {
984 #[rasn(identifier = "verticalAccelerationValue")]
985 pub vertical_acceleration_value: VerticalAccelerationValue,
986 #[rasn(identifier = "verticalAccelerationConfidence")]
987 pub vertical_acceleration_confidence: AccelerationConfidence,
988 }
989 impl VerticalAcceleration {
990 pub fn new(
991 vertical_acceleration_value: VerticalAccelerationValue,
992 vertical_acceleration_confidence: AccelerationConfidence,
993 ) -> Self {
994 Self {
995 vertical_acceleration_value,
996 vertical_acceleration_confidence,
997 }
998 }
999 }
1000 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1001 #[rasn(delegate, value("-160..=161"))]
1002 pub struct VerticalAccelerationValue(pub i16);
1003 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1004 #[rasn(delegate, size("1..=3"))]
1005 pub struct WMInumber(pub Ia5String);
1006 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1007 #[rasn(delegate, value("1..=127"))]
1008 pub struct WheelBaseVehicle(pub u8);
1009 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1010 #[rasn(delegate, value("0..=255"))]
1011 pub struct WrongWayDrivingSubCauseCode(pub u8);
1012 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1013 #[rasn(automatic_tags)]
1014 pub struct YawRate {
1015 #[rasn(identifier = "yawRateValue")]
1016 pub yaw_rate_value: YawRateValue,
1017 #[rasn(identifier = "yawRateConfidence")]
1018 pub yaw_rate_confidence: YawRateConfidence,
1019 }
1020 impl YawRate {
1021 pub fn new(yaw_rate_value: YawRateValue, yaw_rate_confidence: YawRateConfidence) -> Self {
1022 Self {
1023 yaw_rate_value,
1024 yaw_rate_confidence,
1025 }
1026 }
1027 }
1028 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
1029 #[rasn(enumerated)]
1030 pub enum YawRateConfidence {
1031 #[rasn(identifier = "degSec-000-01")]
1032 degSec_000_01 = 0,
1033 #[rasn(identifier = "degSec-000-05")]
1034 degSec_000_05 = 1,
1035 #[rasn(identifier = "degSec-000-10")]
1036 degSec_000_10 = 2,
1037 #[rasn(identifier = "degSec-001-00")]
1038 degSec_001_00 = 3,
1039 #[rasn(identifier = "degSec-005-00")]
1040 degSec_005_00 = 4,
1041 #[rasn(identifier = "degSec-010-00")]
1042 degSec_010_00 = 5,
1043 #[rasn(identifier = "degSec-100-00")]
1044 degSec_100_00 = 6,
1045 outOfRange = 7,
1046 unavailable = 8,
1047 }
1048 #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
1049 #[rasn(delegate, value("-32766..=32767"))]
1050 pub struct YawRateValue(pub i16);
1051}