#[allow(
non_camel_case_types,
non_snake_case,
non_upper_case_globals,
unused,
clippy::too_many_arguments
)]
pub mod aviaeinumbering_and_data_structures {
extern crate alloc;
use core::borrow::Borrow;
use rasn::prelude::*;
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=63"))]
pub struct AlphabetIndicator(pub u8);
#[doc = " 6 bits, latinAlphabetNo1 recommended "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate)]
pub struct AviEriDateTime(pub FixedOctetString<10usize>);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct CS1 {
#[rasn(identifier = "countryCode")]
pub country_code: CountryCode,
#[rasn(identifier = "issuerIdentifier")]
pub issuer_identifier: IssuerIdentifier,
#[rasn(identifier = "serviceNumber")]
pub service_number: ServiceNumber,
}
impl CS1 {
pub fn new(
country_code: CountryCode,
issuer_identifier: IssuerIdentifier,
service_number: ServiceNumber,
) -> Self {
Self {
country_code,
issuer_identifier,
service_number,
}
}
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct CS2 {
#[rasn(identifier = "manufacturerIdentifier")]
pub manufacturer_identifier: ManufacturerIdentifier,
#[rasn(identifier = "serviceNumber")]
pub service_number: ServiceNumber,
}
impl CS2 {
pub fn new(
manufacturer_identifier: ManufacturerIdentifier,
service_number: ServiceNumber,
) -> Self {
Self {
manufacturer_identifier,
service_number,
}
}
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct CS3 {
#[rasn(identifier = "startTime")]
pub start_time: StartTime,
#[rasn(identifier = "stopTime")]
pub stop_time: StopTime,
#[rasn(identifier = "geographLimit")]
pub geograph_limit: GeoGraphicalLimit,
#[rasn(identifier = "serviceAppLimit")]
pub service_app_limit: ServiceApplicationLimit,
}
impl CS3 {
pub fn new(
start_time: StartTime,
stop_time: StopTime,
geograph_limit: GeoGraphicalLimit,
service_app_limit: ServiceApplicationLimit,
) -> Self {
Self {
start_time,
stop_time,
geograph_limit,
service_app_limit,
}
}
}
#[doc = "CS4::= SEQUENCE {"]
#[doc = "\tcountryCode \t\tCountryCode,"]
#[doc = "\talphabetIndicator \tAlphabetIndicator, "]
#[doc = "\tlicPlateNumber \t\tLicPlateNumber"]
#[doc = "\t}"]
#[doc = "\t"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct CS4 {
#[rasn(identifier = "countryCode")]
pub country_code: CountryCode,
#[rasn(identifier = "alphabetIndicator")]
pub alphabet_indicator: AlphabetIndicator,
#[rasn(identifier = "licPlateNumber")]
pub lic_plate_number: LicPlateNumber,
}
impl CS4 {
pub fn new(
country_code: CountryCode,
alphabet_indicator: AlphabetIndicator,
lic_plate_number: LicPlateNumber,
) -> Self {
Self {
country_code,
alphabet_indicator,
lic_plate_number,
}
}
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct CS5 {
pub vin: VisibleString,
#[rasn(size("9"))]
pub fill: BitString,
}
impl CS5 {
pub fn new(vin: VisibleString, fill: BitString) -> Self {
Self { vin, fill }
}
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate)]
pub struct CS7(pub FreightContainerData);
#[doc = " 12 octets"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct CS8 {
#[rasn(size("6"))]
pub fill: BitString,
#[rasn(identifier = "countryCode")]
pub country_code: CountryCode,
#[rasn(identifier = "taxCode")]
pub tax_code: TaxCode,
}
impl CS8 {
pub fn new(fill: BitString, country_code: CountryCode, tax_code: TaxCode) -> Self {
Self {
fill,
country_code,
tax_code,
}
}
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate)]
pub struct CountryCode(pub FixedBitString<10usize>);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct FreightContainerData {
#[rasn(size("19"), identifier = "ownerCode")]
pub owner_code: BitString,
#[rasn(value("0..=1000000"), identifier = "serialNumber")]
pub serial_number: u32,
#[rasn(value("0..=10"), identifier = "checkDigit")]
pub check_digit: u8,
#[rasn(value("1..=2000"))]
pub length: u16,
#[rasn(value("1..=500"))]
pub height: u16,
#[rasn(value("200..=300"))]
pub width: u16,
#[rasn(value("0..=127"), identifier = "containerTypeCode")]
pub container_type_code: u8,
#[rasn(value("19..=500"), identifier = "maximumGrossMass")]
pub maximum_gross_mass: u16,
#[rasn(value("0..=99"), identifier = "tareMass")]
pub tare_mass: u8,
#[rasn(size("3"))]
pub fill: BitString,
}
impl FreightContainerData {
pub fn new(
owner_code: BitString,
serial_number: u32,
check_digit: u8,
length: u16,
height: u16,
width: u16,
container_type_code: u8,
maximum_gross_mass: u16,
tare_mass: u8,
fill: BitString,
) -> Self {
Self {
owner_code,
serial_number,
check_digit,
length,
height,
width,
container_type_code,
maximum_gross_mass,
tare_mass,
fill,
}
}
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate)]
pub struct GeoGraphicalLimit(pub FixedBitString<8usize>);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=16383"))]
pub struct IssuerIdentifier(pub u16);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate)]
pub struct LicPlateNumber(pub OctetString);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=65535"))]
pub struct ManufacturerIdentifier(pub u16);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate)]
pub struct ServiceApplicationLimit(pub FixedBitString<8usize>);
#[doc = "ServiceNumber::= BIT STRING(SIZE(32))"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate)]
pub struct ServiceNumber(pub FixedBitString<32usize>);
#[doc = " YYMMDDhhmm"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate)]
pub struct StartTime(pub AviEriDateTime);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate)]
pub struct StopTime(pub AviEriDateTime);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate)]
pub struct TaxCode(pub OctetString);
}
#[allow(
non_camel_case_types,
non_snake_case,
non_upper_case_globals,
unused,
clippy::too_many_arguments
)]
pub mod citsappl_mgmt_ids {
extern crate alloc;
use core::borrow::Borrow;
use rasn::prelude::*;
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(choice)]
pub enum Ext1 {
#[rasn(value("128..=16511"), tag(context, 0))]
content(u16),
#[rasn(tag(context, 1))]
extension(Ext2),
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(choice)]
pub enum Ext2 {
#[rasn(value("16512..=2113663"), tag(context, 0))]
content(u32),
#[rasn(tag(context, 1))]
extension(Ext3),
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("2113664..=270549119", extensible))]
pub struct Ext3(pub Integer);
#[doc = " End of IMPORTS"]
#[doc = " Types"]
#[doc = " Variable length data types"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(choice)]
pub enum VarLengthNumber {
#[rasn(value("0..=127"), tag(context, 0))]
content(u8),
#[rasn(tag(context, 1))]
extension(Ext1),
}
#[doc = " four and more octets length"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(choice)]
pub enum VarLengthNumber2 {
#[rasn(value("0..=127"), tag(context, 0))]
shortNo(u8),
#[rasn(value("0..=32767"), tag(context, 1))]
longNo(u16),
}
#[doc = " Values"]
pub const VERSION: u8 = 1;
}
#[allow(
non_camel_case_types,
non_snake_case,
non_upper_case_globals,
unused,
clippy::too_many_arguments
)]
pub mod efc_dsrc_application {
extern crate alloc;
use core::borrow::Borrow;
use rasn::prelude::*;
use super::aviaeinumbering_and_data_structures::{CS5, CountryCode, IssuerIdentifier};
#[doc = " defined in ISO 14816 "]
#[doc = " NOTE: The following are the definitions of the action and response"]
#[doc = " parameters"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct AxleWeightLimits {
#[rasn(identifier = "maxLadenweightOnAxle1")]
pub max_ladenweight_on_axle1: Int2,
#[rasn(identifier = "maxLadenweightOnAxle2")]
pub max_ladenweight_on_axle2: Int2,
#[rasn(identifier = "maxLadenweightOnAxle3")]
pub max_ladenweight_on_axle3: Int2,
#[rasn(identifier = "maxLadenweightOnAxle4")]
pub max_ladenweight_on_axle4: Int2,
#[rasn(identifier = "maxLadenweightOnAxle5")]
pub max_ladenweight_on_axle5: Int2,
}
impl AxleWeightLimits {
pub fn new(
max_ladenweight_on_axle1: Int2,
max_ladenweight_on_axle2: Int2,
max_ladenweight_on_axle3: Int2,
max_ladenweight_on_axle4: Int2,
max_ladenweight_on_axle5: Int2,
) -> Self {
Self {
max_ladenweight_on_axle1,
max_ladenweight_on_axle2,
max_ladenweight_on_axle3,
max_ladenweight_on_axle4,
max_ladenweight_on_axle5,
}
}
}
#[doc = " 4 bits, EURO-Classes as defined in EC directive 88/77/EEC, annex 1"]
#[doc = " and in 91/542/EEC, 96/1/EC, 1999/96/EC, 2001/27/EC, regulation No 595/2009"]
#[doc = " and for EEV in Section 6.2.1 of Annex I in EC directive 2005/55/EC"]
#[doc = " EUR-Class VI as defined in Regulation (EC) No 595/2009"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
#[rasn(enumerated)]
pub enum CopValue {
noEntry = 0,
co2class1 = 1,
co2class2 = 2,
co2class3 = 3,
co2class4 = 4,
co2class5 = 5,
co2class6 = 6,
co2class7 = 7,
reservedforUse = 8,
}
#[doc = " NOTE: The following are the definitions of EFC attributes"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct DateCompact {
#[rasn(value("1990..=2117"))]
pub year: u16,
#[rasn(value("0..=12"))]
pub month: u8,
#[rasn(value("0..=31"))]
pub day: u8,
}
impl DateCompact {
pub fn new(year: u16, month: u8, day: u8) -> Self {
Self { year, month, day }
}
}
#[doc = " Inner type "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct DieselEmissionValuesParticulate {
#[rasn(identifier = "unitType")]
pub unit_type: UnitType,
#[rasn(value("0..=32767"))]
pub value: u16,
}
impl DieselEmissionValuesParticulate {
pub fn new(unit_type: UnitType, value: u16) -> Self {
Self { unit_type, value }
}
}
#[doc = " The value \"{year 1990, month 0, day 0}\" is a 16-bit all-zero"]
#[doc = " encoding, and is used to represent \"no date\"."]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct DieselEmissionValues {
pub particulate: DieselEmissionValuesParticulate,
#[rasn(identifier = "absorptionCoeff")]
pub absorption_coeff: Int2,
}
impl DieselEmissionValues {
pub fn new(particulate: DieselEmissionValuesParticulate, absorption_coeff: Int2) -> Self {
Self {
particulate,
absorption_coeff,
}
}
}
#[doc = " 4 bits, reserved for carbon dioxide pollution values as defined in"]
#[doc = " EC directive 2003/127/EC'"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=255"))]
pub struct EngineCharacteristics(pub u8);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct EnvironmentalCharacteristics {
#[rasn(identifier = "euroValue")]
pub euro_value: EuroValue,
#[rasn(identifier = "copValue")]
pub cop_value: CopValue,
}
impl EnvironmentalCharacteristics {
pub fn new(euro_value: EuroValue, cop_value: CopValue) -> Self {
Self {
euro_value,
cop_value,
}
}
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
#[rasn(enumerated)]
pub enum EuroValue {
noEntry = 0,
#[rasn(identifier = "euro-1")]
euro_1 = 1,
#[rasn(identifier = "euro-2")]
euro_2 = 2,
#[rasn(identifier = "euro-3")]
euro_3 = 3,
#[rasn(identifier = "euro-4")]
euro_4 = 4,
#[rasn(identifier = "euro-5")]
euro_5 = 5,
#[rasn(identifier = "euro-6")]
euro_6 = 6,
reservedForUse1 = 7,
reservedForUse2 = 8,
reservedForUse3 = 9,
reservedForUse4 = 10,
reservedForUse5 = 11,
reservedForUse6 = 12,
reservedForUse7 = 13,
reservedForUse8 = 14,
eev = 15,
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct ExhaustEmissionValues {
#[rasn(identifier = "unitType")]
pub unit_type: UnitType,
#[rasn(value("0..=32767"), identifier = "emissionCO")]
pub emission_co: u16,
#[rasn(identifier = "emissionHC")]
pub emission_hc: Int2,
#[rasn(identifier = "emissionNOX")]
pub emission_nox: Int2,
#[rasn(identifier = "emissionHCNOX")]
pub emission_hcnox: Int2,
}
impl ExhaustEmissionValues {
pub fn new(
unit_type: UnitType,
emission_co: u16,
emission_hc: Int2,
emission_nox: Int2,
emission_hcnox: Int2,
) -> Self {
Self {
unit_type,
emission_co,
emission_hc,
emission_nox,
emission_hcnox,
}
}
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=255"))]
pub struct Int1(pub u8);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=65535"))]
pub struct Int2(pub u16);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=16777215"))]
pub struct Int3(pub u32);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=4294967295"))]
pub struct Int4(pub u32);
#[doc = " Inner type "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
#[rasn(enumerated)]
pub enum LPNAlphabetIndicator {
latinAlphabetNo1 = 1,
latinAlphabetNo2 = 2,
latinAlphabetNo3 = 3,
latinAlphabetNo4 = 4,
latinCyrillicAlphabet = 5,
latinArabicAlphabet = 6,
latinGreekAlphabet = 7,
latinHebrewAlphabet = 8,
latinAlphabetNo5 = 9,
latinAlphabetNo6 = 10,
twoOctetBMP = 11,
fourOctetCanonical = 12,
reservedForUse1 = 13,
reservedForUse2 = 14,
reservedForUse3 = 15,
reservedForUse4 = 16,
reservedForUse5 = 17,
reservedForUse6 = 18,
reservedForUse7 = 19,
reservedForUse8 = 20,
reservedForUse9 = 21,
reservedForUse10 = 22,
reservedForUse11 = 23,
reservedForUse12 = 24,
reservedForUse13 = 25,
reservedForUse14 = 26,
reservedForUse15 = 27,
reservedForUse16 = 28,
reservedForUse17 = 29,
reservedForUse18 = 30,
reservedForUse19 = 31,
reservedForUse20 = 32,
reservedForUse21 = 33,
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct LPN {
#[rasn(identifier = "countryCode")]
pub country_code: CountryCode,
#[rasn(identifier = "alphabetIndicator")]
pub alphabet_indicator: LPNAlphabetIndicator,
#[rasn(identifier = "licencePlateNumber")]
pub licence_plate_number: OctetString,
}
impl LPN {
pub fn new(
country_code: CountryCode,
alphabet_indicator: LPNAlphabetIndicator,
licence_plate_number: OctetString,
) -> Self {
Self {
country_code,
alphabet_indicator,
licence_plate_number,
}
}
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct PassengerCapacity {
#[rasn(identifier = "numberOfSeats")]
pub number_of_seats: Int1,
#[rasn(identifier = "numberOfStandingPlaces")]
pub number_of_standing_places: Int1,
}
impl PassengerCapacity {
pub fn new(number_of_seats: Int1, number_of_standing_places: Int1) -> Self {
Self {
number_of_seats,
number_of_standing_places,
}
}
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate)]
pub struct PayUnit(pub FixedOctetString<2usize>);
#[doc = " corresponds to a �3 octets Signed Integer�, associated with the following"]
#[doc = " examples of line codes:"]
#[doc = " -8'388'608 : 80 00 00'H"]
#[doc = " -1 : FF FF FF'H"]
#[doc = " 0 : 00 00 00'H"]
#[doc = " 1 : 00 00 01�H"]
#[doc = " 8'388'607 : 7F FF FF'H"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate)]
pub struct PaymentMeansUnit(pub PayUnit);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate)]
pub struct PaymentSecurityData(pub OctetString);
#[doc = " The unique designation of a Currency as defined in ISO 4217"]
#[doc = " using the ISO numeric binary coded decimal representation."]
#[doc = " The code can also express a company specific token or a"]
#[doc = " \"charging unit code\" as used in the freight.unit in which"]
#[doc = " the fee is expressed."]
#[doc = " Value Assignment :"]
#[doc = " '0xxx'H Currency in main units"]
#[doc = " '1xxx'H Currency in minor units of 10 :1 ('dime')"]
#[doc = " '2xxx'H Currency in minor units of 100 :1 ('cents')"]
#[doc = " '3xxx'H Currency in minor units of 1000 :1"]
#[doc = " '4xxx'H Currency in 'major' units / 10"]
#[doc = " (e.g. 10 Belgian Francs)"]
#[doc = " '5xxx'H Currency in 'major' units / 100"]
#[doc = " (e.g. 100 Italian Lire)"]
#[doc = " '6xxx'H Currency in 'major' units / 1000"]
#[doc = " '7xxx'H Currency in 'major' units / 10000"]
#[doc = " '8xxx'H Currency in 'major' units / 100000"]
#[doc = " where xxx is the BCD representation of \"Currency\""]
#[doc = " as defined in ISO 4217"]
#[doc = " '9xxx'H Tokens"]
#[doc = " where xxx is Purse Provider specific coding."]
#[doc = " 'Axxx'H Charging Unit Codes,"]
#[doc = " denoting quantification of the service provided"]
#[doc = " (e.g. man-hours)"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate)]
pub struct PersonalAccountNumber(pub FixedOctetString<10usize>);
#[doc = " Personal account number structure � according to ISO/IEC 7812-1"]
#[doc = " Issuer identifier number (�BIN�)"]
#[doc = " Major industry identifier (MII, 1 binary coded decimal, BCD)"]
#[doc = " 0 : reserved for future use by ISO/TC68"]
#[doc = " 1 : airline sector"]
#[doc = " 2 : extended airline sector"]
#[doc = " 3 : travel and tourism sector"]
#[doc = " 4 : financial banking sector"]
#[doc = " 5 : financial banking sector"]
#[doc = " 6 : commerce and banking sector"]
#[doc = " 7 : petrol industry sector"]
#[doc = " 8 : telecommunication sector"]
#[doc = " 9 : reserved for national use"]
#[doc = " Issuer identifier (5 BCD in the second edition of ISO/IEC 7812-1)"]
#[doc = " Account number (max 12 BCD)"]
#[doc = " Control digit (1 BCD)"]
#[doc = " Padding bits, set to 1'B, in order to accomplish a"]
#[doc = " total length of 10 octets."]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct Provider {
#[rasn(identifier = "countryCode")]
pub country_code: CountryCode,
#[rasn(identifier = "providerIdentifier")]
pub provider_identifier: IssuerIdentifier,
}
impl Provider {
pub fn new(country_code: CountryCode, provider_identifier: IssuerIdentifier) -> Self {
Self {
country_code,
provider_identifier,
}
}
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(choice, automatic_tags)]
pub enum SignedValue {
#[rasn(value("0..=8388607"))]
positive(u32),
#[rasn(value("-8388608..=-1"))]
negative(i32),
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct SoundLevel {
pub soundstationary: Int1,
pub sounddriveby: Int1,
}
impl SoundLevel {
pub fn new(soundstationary: Int1, sounddriveby: Int1) -> Self {
Self {
soundstationary,
sounddriveby,
}
}
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
#[rasn(enumerated)]
pub enum UnitType {
#[rasn(identifier = "mg-km")]
mg_km = 0,
#[rasn(identifier = "mg-kWh")]
mg_kWh = 1,
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct VehicleDimensions {
#[rasn(identifier = "vehicleLengthOverall")]
pub vehicle_length_overall: Int1,
#[rasn(identifier = "vehicleHeigthOverall")]
pub vehicle_heigth_overall: Int1,
#[rasn(identifier = "vehicleWidthOverall")]
pub vehicle_width_overall: Int1,
}
impl VehicleDimensions {
pub fn new(
vehicle_length_overall: Int1,
vehicle_heigth_overall: Int1,
vehicle_width_overall: Int1,
) -> Self {
Self {
vehicle_length_overall,
vehicle_heigth_overall,
vehicle_width_overall,
}
}
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct VehicleWeightLimits {
#[rasn(identifier = "vehicleMaxLadenWeight")]
pub vehicle_max_laden_weight: Int2,
#[rasn(identifier = "vehicleTrainMaximumWeight")]
pub vehicle_train_maximum_weight: Int2,
#[rasn(identifier = "vehicleWeightUnladen")]
pub vehicle_weight_unladen: Int2,
}
impl VehicleWeightLimits {
pub fn new(
vehicle_max_laden_weight: Int2,
vehicle_train_maximum_weight: Int2,
vehicle_weight_unladen: Int2,
) -> Self {
Self {
vehicle_max_laden_weight,
vehicle_train_maximum_weight,
vehicle_weight_unladen,
}
}
}
}
#[allow(
non_camel_case_types,
non_snake_case,
non_upper_case_globals,
unused,
clippy::too_many_arguments
)]
pub mod electronic_registration_identification_vehicle_data_module {
extern crate alloc;
use core::borrow::Borrow;
use rasn::prelude::*;
#[doc = " Electronic Registration Identification (ERI)- Vehicle Data"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(choice, automatic_tags)]
pub enum EuVehicleCategoryCode {
euVehicleCategoryL(EuVehicleCategoryL),
euVehicleCategoryM(EuVehicleCategoryM),
euVehicleCategoryN(EuVehicleCategoryN),
euVehicleCategoryO(EuVehicleCategoryO),
euVehilcleCategoryT(()),
euVehilcleCategoryG(()),
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
#[rasn(enumerated)]
pub enum EuVehicleCategoryL {
l1 = 0,
l2 = 1,
l3 = 2,
l4 = 3,
l5 = 4,
l6 = 5,
l7 = 6,
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
#[rasn(enumerated)]
pub enum EuVehicleCategoryM {
m1 = 0,
m2 = 1,
m3 = 2,
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
#[rasn(enumerated)]
pub enum EuVehicleCategoryN {
n1 = 0,
n2 = 1,
n3 = 2,
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
#[rasn(enumerated)]
pub enum EuVehicleCategoryO {
o1 = 0,
o2 = 1,
o3 = 2,
o4 = 3,
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=255"))]
pub struct Iso3833VehicleType(pub u8);
}
#[allow(
non_camel_case_types,
non_snake_case,
non_upper_case_globals,
unused,
clippy::too_many_arguments
)]
pub mod gdd {
extern crate alloc;
use core::borrow::Borrow;
use rasn::prelude::*;
#[doc = " Definition of data elements used in ISO 14823 attributes"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, identifier = "Code-Units", value("0..=15"))]
pub struct CodeUnits(pub u8);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags, identifier = "DDD-IO")]
pub struct DDDIO {
#[rasn(value("0..=7"), identifier = "arrowDirection")]
pub arrow_direction: u8,
#[rasn(identifier = "destPlace")]
pub dest_place: Option<DestinationPlaces>,
#[rasn(identifier = "destRoad")]
pub dest_road: Option<DestinationRoads>,
#[rasn(value("1..=999"), identifier = "roadNumberIdentifier")]
pub road_number_identifier: Option<u16>,
#[rasn(value("1..=999"), identifier = "streetName")]
pub street_name: Option<u16>,
#[rasn(identifier = "streetNameText")]
pub street_name_text: Option<Utf8String>,
#[rasn(identifier = "distanceToDivergingPoint")]
pub distance_to_diverging_point: Option<DistanceOrDuration>,
#[rasn(identifier = "distanceToDestinationPlace")]
pub distance_to_destination_place: Option<DistanceOrDuration>,
}
impl DDDIO {
pub fn new(
arrow_direction: u8,
dest_place: Option<DestinationPlaces>,
dest_road: Option<DestinationRoads>,
road_number_identifier: Option<u16>,
street_name: Option<u16>,
street_name_text: Option<Utf8String>,
distance_to_diverging_point: Option<DistanceOrDuration>,
distance_to_destination_place: Option<DistanceOrDuration>,
) -> Self {
Self {
arrow_direction,
dest_place,
dest_road,
road_number_identifier,
street_name,
street_name_text,
distance_to_diverging_point,
distance_to_destination_place,
}
}
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=8", extensible), identifier = "DDD-IO-LIST")]
pub struct DDDIOLIST(pub SequenceOf<DDDIO>);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate)]
pub struct DayOfWeek(pub FixedBitString<8usize>);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct DestinationPlace {
#[rasn(identifier = "destType")]
pub dest_type: DestinationType,
#[rasn(value("0.."), identifier = "destRSCode")]
pub dest_rscode: Option<GddStructure>,
#[rasn(identifier = "destBlob")]
pub dest_blob: Option<OctetString>,
#[rasn(value("1..=999"), identifier = "placeNameIdentification")]
pub place_name_identification: Option<u16>,
#[rasn(identifier = "placeNameText")]
pub place_name_text: Option<Utf8String>,
}
impl DestinationPlace {
pub fn new(
dest_type: DestinationType,
dest_rscode: Option<GddStructure>,
dest_blob: Option<OctetString>,
place_name_identification: Option<u16>,
place_name_text: Option<Utf8String>,
) -> Self {
Self {
dest_type,
dest_rscode,
dest_blob,
place_name_identification,
place_name_text,
}
}
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=4", extensible))]
pub struct DestinationPlaces(pub SequenceOf<DestinationPlace>);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct DestinationRoad {
#[rasn(identifier = "derType")]
pub der_type: DestinationRoadType,
#[rasn(value("1..=999"), identifier = "roadNumberIdentifier")]
pub road_number_identifier: Option<u16>,
#[rasn(identifier = "roadNumberText")]
pub road_number_text: Option<Utf8String>,
}
impl DestinationRoad {
pub fn new(
der_type: DestinationRoadType,
road_number_identifier: Option<u16>,
road_number_text: Option<Utf8String>,
) -> Self {
Self {
der_type,
road_number_identifier,
road_number_text,
}
}
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=15", extensible))]
pub struct DestinationRoadType(pub Integer);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=4", extensible))]
pub struct DestinationRoads(pub SequenceOf<DestinationRoad>);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=15", extensible))]
pub struct DestinationType(pub Integer);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct Distance {
#[rasn(value("1..=16384"))]
pub value: u16,
#[rasn(value("2..=8"))]
pub unit: CodeUnits,
}
impl Distance {
pub fn new(value: u16, unit: CodeUnits) -> Self {
Self { value, unit }
}
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct DistanceOrDuration {
#[rasn(value("1..=16384"))]
pub value: u16,
#[rasn(value("2..=9"))]
pub unit: CodeUnits,
}
impl DistanceOrDuration {
pub fn new(value: u16, unit: CodeUnits) -> Self {
Self { value, unit }
}
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(choice, automatic_tags)]
pub enum GddAttribute {
dtm(InternationalSignApplicablePeriod),
edt(InternationalSignExemptedApplicablePeriod),
dfl(InternationalSignDirectionalFlowOfLane),
ved(InternationalSignApplicableVehicleDimensions),
spe(InternationalSignSpeedLimits),
roi(InternationalSignRateOfIncline),
dbv(InternationalSignDistanceBetweenVehicles),
ddd(InternationalSignDestinationInformation),
set(InternationalSignSection),
nol(InternationalSignNumberOfLane),
}
#[doc = " Definition of the single ISO 14823 Attributes"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=8", extensible))]
pub struct GddAttributes(pub SequenceOf<GddAttribute>);
#[doc = " Inner type "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
#[rasn(enumerated)]
#[non_exhaustive]
pub enum GddStructurePictogramCodeServiceCategoryCodeTrafficSignPictogram {
dangerWarning = 0,
regulatory = 1,
informative = 2,
}
#[doc = " Inner type "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
#[rasn(enumerated)]
#[non_exhaustive]
pub enum GddStructurePictogramCodeServiceCategoryCodePublicFacilitiesPictogram {
publicFacilities = 0,
}
#[doc = " Inner type "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
#[rasn(enumerated)]
#[non_exhaustive]
pub enum GddStructurePictogramCodeServiceCategoryCodeAmbientOrRoadConditionPictogram {
ambientCondition = 0,
roadCondition = 1,
}
#[doc = " Inner type "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(choice, automatic_tags)]
#[non_exhaustive]
pub enum GddStructurePictogramCodeServiceCategoryCode {
trafficSignPictogram(GddStructurePictogramCodeServiceCategoryCodeTrafficSignPictogram),
publicFacilitiesPictogram(
GddStructurePictogramCodeServiceCategoryCodePublicFacilitiesPictogram,
),
ambientOrRoadConditionPictogram(
GddStructurePictogramCodeServiceCategoryCodeAmbientOrRoadConditionPictogram,
),
}
#[doc = " Inner type "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct GddStructurePictogramCodePictogramCategoryCode {
#[rasn(value("1..=9"))]
pub nature: u8,
#[rasn(value("0..=99"), identifier = "serialNumber")]
pub serial_number: u8,
}
impl GddStructurePictogramCodePictogramCategoryCode {
pub fn new(nature: u8, serial_number: u8) -> Self {
Self {
nature,
serial_number,
}
}
}
#[doc = " Inner type "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct GddStructurePictogramCode {
#[rasn(size("2"), identifier = "countryCode")]
pub country_code: Option<OctetString>,
#[rasn(identifier = "serviceCategoryCode")]
pub service_category_code: GddStructurePictogramCodeServiceCategoryCode,
#[rasn(identifier = "pictogramCategoryCode")]
pub pictogram_category_code: GddStructurePictogramCodePictogramCategoryCode,
}
impl GddStructurePictogramCode {
pub fn new(
country_code: Option<OctetString>,
service_category_code: GddStructurePictogramCodeServiceCategoryCode,
pictogram_category_code: GddStructurePictogramCodePictogramCategoryCode,
) -> Self {
Self {
country_code,
service_category_code,
pictogram_category_code,
}
}
}
#[doc = "Definition of GDD Structure"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct GddStructure {
#[rasn(identifier = "pictogramCode")]
pub pictogram_code: GddStructurePictogramCode,
pub attributes: Option<GddAttributes>,
}
impl GddStructure {
pub fn new(
pictogram_code: GddStructurePictogramCode,
attributes: Option<GddAttributes>,
) -> Self {
Self {
pictogram_code,
attributes,
}
}
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct HoursMinutes {
#[rasn(value("0..=23"))]
pub hours: u8,
#[rasn(value("0..=59"))]
pub mins: u8,
}
impl HoursMinutes {
pub fn new(hours: u8, mins: u8) -> Self {
Self { hours, mins }
}
}
#[doc = " Inner type "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct InternationalSignApplicablePeriodYear {
#[rasn(value("2000..=2127", extensible), identifier = "yearRangeStartYear")]
pub year_range_start_year: Integer,
#[rasn(value("2000..=2127", extensible), identifier = "yearRangeEndYear")]
pub year_range_end_year: Integer,
}
impl InternationalSignApplicablePeriodYear {
pub fn new(year_range_start_year: Integer, year_range_end_year: Integer) -> Self {
Self {
year_range_start_year,
year_range_end_year,
}
}
}
#[doc = " Inner type "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct InternationalSignApplicablePeriodMonthDay {
#[rasn(identifier = "dateRangeStartMonthDay")]
pub date_range_start_month_day: MonthDay,
#[rasn(identifier = "dateRangeEndMonthDay")]
pub date_range_end_month_day: MonthDay,
}
impl InternationalSignApplicablePeriodMonthDay {
pub fn new(
date_range_start_month_day: MonthDay,
date_range_end_month_day: MonthDay,
) -> Self {
Self {
date_range_start_month_day,
date_range_end_month_day,
}
}
}
#[doc = " Inner type "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct InternationalSignApplicablePeriodHourMinutes {
#[rasn(identifier = "timeRangeStartTime")]
pub time_range_start_time: HoursMinutes,
#[rasn(identifier = "timeRangeEndTime")]
pub time_range_end_time: HoursMinutes,
}
impl InternationalSignApplicablePeriodHourMinutes {
pub fn new(time_range_start_time: HoursMinutes, time_range_end_time: HoursMinutes) -> Self {
Self {
time_range_start_time,
time_range_end_time,
}
}
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags, identifier = "InternationalSign-applicablePeriod")]
pub struct InternationalSignApplicablePeriod {
pub year: Option<InternationalSignApplicablePeriodYear>,
#[rasn(identifier = "month-day")]
pub month_day: Option<InternationalSignApplicablePeriodMonthDay>,
#[rasn(identifier = "repeatingPeriodDayTypes")]
pub repeating_period_day_types: Option<RepeatingPeriodDayTypes>,
#[rasn(identifier = "hourMinutes")]
pub hour_minutes: Option<InternationalSignApplicablePeriodHourMinutes>,
#[rasn(identifier = "dateRangeOfWeek")]
pub date_range_of_week: Option<DayOfWeek>,
#[rasn(identifier = "durationHourMinute")]
pub duration_hour_minute: Option<HoursMinutes>,
}
impl InternationalSignApplicablePeriod {
pub fn new(
year: Option<InternationalSignApplicablePeriodYear>,
month_day: Option<InternationalSignApplicablePeriodMonthDay>,
repeating_period_day_types: Option<RepeatingPeriodDayTypes>,
hour_minutes: Option<InternationalSignApplicablePeriodHourMinutes>,
date_range_of_week: Option<DayOfWeek>,
duration_hour_minute: Option<HoursMinutes>,
) -> Self {
Self {
year,
month_day,
repeating_period_day_types,
hour_minutes,
date_range_of_week,
duration_hour_minute,
}
}
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(
automatic_tags,
identifier = "InternationalSign-applicableVehicleDimensions"
)]
pub struct InternationalSignApplicableVehicleDimensions {
#[rasn(identifier = "vehicleHeight")]
pub vehicle_height: Option<Distance>,
#[rasn(identifier = "vehicleWidth")]
pub vehicle_width: Option<Distance>,
#[rasn(identifier = "vehicleLength")]
pub vehicle_length: Option<Distance>,
#[rasn(identifier = "vehicleWeight")]
pub vehicle_weight: Option<Weight>,
}
impl InternationalSignApplicableVehicleDimensions {
pub fn new(
vehicle_height: Option<Distance>,
vehicle_width: Option<Distance>,
vehicle_length: Option<Distance>,
vehicle_weight: Option<Weight>,
) -> Self {
Self {
vehicle_height,
vehicle_width,
vehicle_length,
vehicle_weight,
}
}
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(
automatic_tags,
identifier = "InternationalSign-destinationInformation"
)]
pub struct InternationalSignDestinationInformation {
#[rasn(value("1..=128"), identifier = "junctionDirection")]
pub junction_direction: Option<u8>,
#[rasn(value("1..=128"), identifier = "roundaboutCwDirection")]
pub roundabout_cw_direction: Option<u8>,
#[rasn(value("1..=128"), identifier = "roundaboutCcwDirection")]
pub roundabout_ccw_direction: Option<u8>,
#[rasn(identifier = "ioList")]
pub io_list: DDDIOLIST,
}
impl InternationalSignDestinationInformation {
pub fn new(
junction_direction: Option<u8>,
roundabout_cw_direction: Option<u8>,
roundabout_ccw_direction: Option<u8>,
io_list: DDDIOLIST,
) -> Self {
Self {
junction_direction,
roundabout_cw_direction,
roundabout_ccw_direction,
io_list,
}
}
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(
delegate,
identifier = "InternationalSign-directionalFlowOfLane",
value("1..=8")
)]
pub struct InternationalSignDirectionalFlowOfLane(pub u8);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, identifier = "InternationalSign-distanceBetweenVehicles")]
pub struct InternationalSignDistanceBetweenVehicles(pub Distance);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, identifier = "InternationalSign-exemptedApplicablePeriod")]
pub struct InternationalSignExemptedApplicablePeriod(pub InternationalSignApplicablePeriod);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(
delegate,
identifier = "InternationalSign-numberOfLane",
value("0..=99")
)]
pub struct InternationalSignNumberOfLane(pub u8);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(
delegate,
identifier = "InternationalSign-rateOfIncline",
value("1..=32")
)]
pub struct InternationalSignRateOfIncline(pub u8);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags, identifier = "InternationalSign-section")]
pub struct InternationalSignSection {
#[rasn(identifier = "startingPointLength")]
pub starting_point_length: Option<Distance>,
#[rasn(identifier = "continuityLength")]
pub continuity_length: Option<Distance>,
}
impl InternationalSignSection {
pub fn new(
starting_point_length: Option<Distance>,
continuity_length: Option<Distance>,
) -> Self {
Self {
starting_point_length,
continuity_length,
}
}
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags, identifier = "InternationalSign-speedLimits")]
pub struct InternationalSignSpeedLimits {
#[rasn(value("0..=250"), identifier = "speedLimitMax")]
pub speed_limit_max: Option<u8>,
#[rasn(value("0..=250"), identifier = "speedLimitMin")]
pub speed_limit_min: Option<u8>,
#[rasn(value("0..=1"))]
pub unit: CodeUnits,
}
impl InternationalSignSpeedLimits {
pub fn new(
speed_limit_max: Option<u8>,
speed_limit_min: Option<u8>,
unit: CodeUnits,
) -> Self {
Self {
speed_limit_max,
speed_limit_min,
unit,
}
}
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct MonthDay {
#[rasn(value("1..=12"))]
pub month: u8,
#[rasn(value("1..=31"))]
pub day: u8,
}
impl MonthDay {
pub fn new(month: u8, day: u8) -> Self {
Self { month, day }
}
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate)]
pub struct RepeatingPeriodDayTypes(pub FixedBitString<4usize>);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct Weight {
#[rasn(value("1..=16384"))]
pub value: u16,
#[rasn(value("10..=12"))]
pub unit: CodeUnits,
}
impl Weight {
pub fn new(value: u16, unit: CodeUnits) -> Self {
Self { value, unit }
}
}
}
#[allow(
non_camel_case_types,
non_snake_case,
non_upper_case_globals,
unused,
clippy::too_many_arguments
)]
pub mod ivi {
extern crate alloc;
use core::borrow::Borrow;
use rasn::prelude::*;
use super::super::cdd_1_3_1_1::its_container::{
ActionID,
Altitude,
DangerousGoodsBasic,
DeltaLatitude,
DeltaLongitude,
DeltaReferencePosition,
Heading,
HeadingValue,
LanePosition,
Latitude,
Longitude,
ReferencePosition,
RoadType,
SpecialTransportType,
Speed,
SpeedValue,
StationType,
TimestampIts,
VehicleRole,
};
use super::super::dsrc_2_2_1::etsi_its_dsrc::{
IntersectionReferenceID,
LaneID,
RoadSegmentReferenceID,
};
use super::citsappl_mgmt_ids::VarLengthNumber;
use super::efc_dsrc_application::{
AxleWeightLimits,
DieselEmissionValues,
EngineCharacteristics,
EnvironmentalCharacteristics,
ExhaustEmissionValues,
PassengerCapacity,
Provider,
SoundLevel,
VehicleDimensions,
VehicleWeightLimits,
};
use super::electronic_registration_identification_vehicle_data_module::{
EuVehicleCategoryCode,
Iso3833VehicleType,
};
use super::gdd::{
InternationalSignApplicablePeriod,
InternationalSignApplicableVehicleDimensions,
InternationalSignDestinationInformation,
InternationalSignDirectionalFlowOfLane,
InternationalSignDistanceBetweenVehicles,
InternationalSignExemptedApplicablePeriod,
InternationalSignRateOfIncline,
InternationalSignSpeedLimits,
};
#[doc = " Definition of Data Frames"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct AbsolutePosition {
pub latitude: Latitude,
pub longitude: Longitude,
}
impl AbsolutePosition {
pub fn new(latitude: Latitude, longitude: Longitude) -> Self {
Self {
latitude,
longitude,
}
}
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct AbsolutePositionWAltitude {
pub latitude: Latitude,
pub longitude: Longitude,
pub altitude: Altitude,
}
impl AbsolutePositionWAltitude {
pub fn new(latitude: Latitude, longitude: Longitude, altitude: Altitude) -> Self {
Self {
latitude,
longitude,
altitude,
}
}
}
#[doc = " Definition of data frames which are lists of data frames"]
#[doc = " note: those definitions are to avoid \"implicit type definitions\" but are bit compatible with V1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=8", extensible))]
pub struct AbsolutePositions(pub SequenceOf<AbsolutePosition>);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=8", extensible))]
pub struct AbsolutePositionsWAltitude(pub SequenceOf<AbsolutePositionWAltitude>);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct AnyCatalogue {
pub owner: Provider,
#[rasn(value("0..=255"))]
pub version: u8,
#[rasn(value("0..=65535"), identifier = "pictogramCode")]
pub pictogram_code: u16,
#[rasn(value("0..=65535"))]
pub value: Option<u16>,
pub unit: Option<RSCUnit>,
pub attributes: Option<ISO14823Attributes>,
}
impl AnyCatalogue {
pub fn new(
owner: Provider,
version: u8,
pictogram_code: u16,
value: Option<u16>,
unit: Option<RSCUnit>,
attributes: Option<ISO14823Attributes>,
) -> Self {
Self {
owner,
version,
pictogram_code,
value,
unit,
attributes,
}
}
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=16", extensible))]
pub struct AutomatedVehicleContainer(pub SequenceOf<AvcPart>);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
#[non_exhaustive]
pub struct AutomatedVehicleRule {
pub priority: PriorityLevel,
#[rasn(identifier = "allowedSaeAutomationLevels")]
pub allowed_sae_automation_levels: SaeAutomationLevels,
#[rasn(identifier = "minGapBetweenVehicles")]
pub min_gap_between_vehicles: Option<GapBetweenVehicles>,
#[rasn(identifier = "recGapBetweenVehicles")]
pub rec_gap_between_vehicles: Option<GapBetweenVehicles>,
#[rasn(identifier = "automatedVehicleMaxSpeedLimit")]
pub automated_vehicle_max_speed_limit: Option<SpeedValue>,
#[rasn(identifier = "automatedVehicleMinSpeedLimit")]
pub automated_vehicle_min_speed_limit: Option<SpeedValue>,
#[rasn(identifier = "automatedVehicleSpeedRecommendation")]
pub automated_vehicle_speed_recommendation: Option<SpeedValue>,
#[rasn(identifier = "roadSignCodes")]
pub road_sign_codes: Option<RoadSignCodes>,
#[rasn(identifier = "extraText")]
pub extra_text: Option<ConstraintTextLines2>,
}
impl AutomatedVehicleRule {
pub fn new(
priority: PriorityLevel,
allowed_sae_automation_levels: SaeAutomationLevels,
min_gap_between_vehicles: Option<GapBetweenVehicles>,
rec_gap_between_vehicles: Option<GapBetweenVehicles>,
automated_vehicle_max_speed_limit: Option<SpeedValue>,
automated_vehicle_min_speed_limit: Option<SpeedValue>,
automated_vehicle_speed_recommendation: Option<SpeedValue>,
road_sign_codes: Option<RoadSignCodes>,
extra_text: Option<ConstraintTextLines2>,
) -> Self {
Self {
priority,
allowed_sae_automation_levels,
min_gap_between_vehicles,
rec_gap_between_vehicles,
automated_vehicle_max_speed_limit,
automated_vehicle_min_speed_limit,
automated_vehicle_speed_recommendation,
road_sign_codes,
extra_text,
}
}
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=5"))]
pub struct AutomatedVehicleRules(pub SequenceOf<AutomatedVehicleRule>);
#[doc = " new container in V2"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
#[non_exhaustive]
pub struct AvcPart {
#[rasn(identifier = "detectionZoneIds")]
pub detection_zone_ids: Option<ZoneIds>,
#[rasn(identifier = "relevanceZoneIds")]
pub relevance_zone_ids: ZoneIds,
pub direction: Option<Direction>,
#[rasn(identifier = "applicableLanes")]
pub applicable_lanes: Option<LanePositions>,
#[rasn(identifier = "vehicleCharacteristics")]
pub vehicle_characteristics: Option<VehicleCharacteristicsList>,
#[rasn(identifier = "automatedVehicleRules")]
pub automated_vehicle_rules: Option<AutomatedVehicleRules>,
#[rasn(identifier = "platooningRules")]
pub platooning_rules: Option<PlatooningRules>,
}
impl AvcPart {
pub fn new(
detection_zone_ids: Option<ZoneIds>,
relevance_zone_ids: ZoneIds,
direction: Option<Direction>,
applicable_lanes: Option<LanePositions>,
vehicle_characteristics: Option<VehicleCharacteristicsList>,
automated_vehicle_rules: Option<AutomatedVehicleRules>,
platooning_rules: Option<PlatooningRules>,
) -> Self {
Self {
detection_zone_ids,
relevance_zone_ids,
direction,
applicable_lanes,
vehicle_characteristics,
automated_vehicle_rules,
platooning_rules,
}
}
}
#[doc = " Defition of IVI specific data elements "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("-20..=21"))]
pub struct BankingAngle(pub i8);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=3"))]
pub struct ComparisonOperator(pub u8);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct CompleteVehicleCharacteristics {
pub tractor: Option<TractorCharacteristics>,
pub trailer: Option<TrailerCharacteristicsList>,
pub train: Option<TrainCharacteristics>,
}
impl CompleteVehicleCharacteristics {
pub fn new(
tractor: Option<TractorCharacteristics>,
trailer: Option<TrailerCharacteristicsList>,
train: Option<TrainCharacteristics>,
) -> Self {
Self {
tractor,
trailer,
train,
}
}
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct ComputedSegment {
#[rasn(identifier = "zoneId")]
pub zone_id: Zid,
#[rasn(identifier = "laneNumber")]
pub lane_number: LanePosition,
#[rasn(identifier = "laneWidth")]
pub lane_width: IviLaneWidth,
#[rasn(value("-32768..=32767"), identifier = "offsetDistance")]
pub offset_distance: Option<i16>,
#[rasn(identifier = "offsetPosition")]
pub offset_position: Option<DeltaReferencePosition>,
}
impl ComputedSegment {
pub fn new(
zone_id: Zid,
lane_number: LanePosition,
lane_width: IviLaneWidth,
offset_distance: Option<i16>,
offset_position: Option<DeltaReferencePosition>,
) -> Self {
Self {
zone_id,
lane_number,
lane_width,
offset_distance,
offset_position,
}
}
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=15", extensible))]
pub struct Condition(pub Integer);
#[doc = " new DF in V2"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=8", extensible))]
pub struct ConnectedDenms(pub SequenceOf<ActionID>);
#[doc = "size extension in V2"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=4", extensible))]
pub struct ConstraintTextLines1(pub SequenceOf<Text>);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=4", extensible))]
pub struct ConstraintTextLines2(pub SequenceOf<Text>);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=7", extensible))]
pub struct DefinitionAccuracy(pub Integer);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct DeltaPosition {
#[rasn(identifier = "deltaLatitude")]
pub delta_latitude: DeltaLatitude,
#[rasn(identifier = "deltaLongitude")]
pub delta_longitude: DeltaLongitude,
}
impl DeltaPosition {
pub fn new(delta_latitude: DeltaLatitude, delta_longitude: DeltaLongitude) -> Self {
Self {
delta_latitude,
delta_longitude,
}
}
}
#[doc = " new DF in V2"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=32", extensible))]
pub struct DeltaPositions(pub SequenceOf<DeltaPosition>);
#[doc = "size extension in V2"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=32", extensible))]
pub struct DeltaReferencePositions(pub SequenceOf<DeltaReferencePosition>);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=255"))]
pub struct Depth(pub u8);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=3"))]
pub struct Direction(pub u8);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=3"))]
pub struct DriverCharacteristics(pub u8);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=101"))]
pub struct FrictionCoefficient(pub u8);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=255"))]
pub struct GapBetweenVehicles(pub u8);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=16", extensible))]
pub struct GeneralIviContainer(pub SequenceOf<GicPart>);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
#[non_exhaustive]
pub struct GeographicLocationContainer {
#[rasn(identifier = "referencePosition")]
pub reference_position: ReferencePosition,
#[rasn(identifier = "referencePositionTime")]
pub reference_position_time: Option<TimestampIts>,
#[rasn(identifier = "referencePositionHeading")]
pub reference_position_heading: Option<Heading>,
#[rasn(identifier = "referencePositionSpeed")]
pub reference_position_speed: Option<Speed>,
pub parts: GlcParts,
}
impl GeographicLocationContainer {
pub fn new(
reference_position: ReferencePosition,
reference_position_time: Option<TimestampIts>,
reference_position_heading: Option<Heading>,
reference_position_speed: Option<Speed>,
parts: GlcParts,
) -> Self {
Self {
reference_position,
reference_position_time,
reference_position_heading,
reference_position_speed,
parts,
}
}
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
#[non_exhaustive]
pub struct GicPart {
#[rasn(identifier = "detectionZoneIds")]
pub detection_zone_ids: Option<ZoneIds>,
#[rasn(identifier = "its-Rrid")]
pub its_rrid: Option<VarLengthNumber>,
#[rasn(identifier = "relevanceZoneIds")]
pub relevance_zone_ids: Option<ZoneIds>,
pub direction: Option<Direction>,
#[rasn(identifier = "driverAwarenessZoneIds")]
pub driver_awareness_zone_ids: Option<ZoneIds>,
#[rasn(value("0..=255"), identifier = "minimumAwarenessTime")]
pub minimum_awareness_time: Option<u8>,
#[rasn(identifier = "applicableLanes")]
pub applicable_lanes: Option<LanePositions>,
#[rasn(identifier = "iviType")]
pub ivi_type: IviType,
#[rasn(identifier = "iviPurpose")]
pub ivi_purpose: Option<IviPurpose>,
#[rasn(identifier = "laneStatus")]
pub lane_status: Option<LaneStatus>,
#[rasn(identifier = "vehicleCharacteristics")]
pub vehicle_characteristics: Option<VehicleCharacteristicsList>,
#[rasn(identifier = "driverCharacteristics")]
pub driver_characteristics: Option<DriverCharacteristics>,
#[rasn(value("1..=4", extensible), identifier = "layoutId")]
pub layout_id: Option<Integer>,
#[rasn(value("1..=64", extensible), identifier = "preStoredlayoutId")]
pub pre_storedlayout_id: Option<Integer>,
#[rasn(identifier = "roadSignCodes")]
pub road_sign_codes: RoadSignCodes,
#[rasn(identifier = "extraText")]
pub extra_text: Option<ConstraintTextLines1>,
}
impl GicPart {
pub fn new(
detection_zone_ids: Option<ZoneIds>,
its_rrid: Option<VarLengthNumber>,
relevance_zone_ids: Option<ZoneIds>,
direction: Option<Direction>,
driver_awareness_zone_ids: Option<ZoneIds>,
minimum_awareness_time: Option<u8>,
applicable_lanes: Option<LanePositions>,
ivi_type: IviType,
ivi_purpose: Option<IviPurpose>,
lane_status: Option<LaneStatus>,
vehicle_characteristics: Option<VehicleCharacteristicsList>,
driver_characteristics: Option<DriverCharacteristics>,
layout_id: Option<Integer>,
pre_storedlayout_id: Option<Integer>,
road_sign_codes: RoadSignCodes,
extra_text: Option<ConstraintTextLines1>,
) -> Self {
Self {
detection_zone_ids,
its_rrid,
relevance_zone_ids,
direction,
driver_awareness_zone_ids,
minimum_awareness_time,
applicable_lanes,
ivi_type,
ivi_purpose,
lane_status,
vehicle_characteristics,
driver_characteristics,
layout_id,
pre_storedlayout_id,
road_sign_codes,
extra_text,
}
}
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
#[non_exhaustive]
pub struct GlcPart {
#[rasn(identifier = "zoneId")]
pub zone_id: Zid,
#[rasn(identifier = "laneNumber")]
pub lane_number: Option<LanePosition>,
#[rasn(value("0..=255"), identifier = "zoneExtension")]
pub zone_extension: Option<u8>,
#[rasn(identifier = "zoneHeading")]
pub zone_heading: Option<HeadingValue>,
pub zone: Option<Zone>,
}
impl GlcPart {
pub fn new(
zone_id: Zid,
lane_number: Option<LanePosition>,
zone_extension: Option<u8>,
zone_heading: Option<HeadingValue>,
zone: Option<Zone>,
) -> Self {
Self {
zone_id,
lane_number,
zone_extension,
zone_heading,
zone,
}
}
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=16", extensible))]
pub struct GlcParts(pub SequenceOf<GlcPart>);
#[doc = " new DE in V2"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=15", extensible))]
pub struct GoodsType(pub Integer);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(choice, automatic_tags)]
pub enum ISO14823Attribute {
dtm(InternationalSignApplicablePeriod),
edt(InternationalSignExemptedApplicablePeriod),
dfl(InternationalSignDirectionalFlowOfLane),
ved(InternationalSignApplicableVehicleDimensions),
spe(InternationalSignSpeedLimits),
roi(InternationalSignRateOfIncline),
dbv(InternationalSignDistanceBetweenVehicles),
ddd(InternationalSignDestinationInformation),
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=8", extensible))]
pub struct ISO14823Attributes(pub SequenceOf<ISO14823Attribute>);
#[doc = " Inner type "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
#[rasn(enumerated)]
#[non_exhaustive]
pub enum ISO14823CodePictogramCodeServiceCategoryCodeTrafficSignPictogram {
dangerWarning = 0,
regulatory = 1,
informative = 2,
}
#[doc = " Inner type "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
#[rasn(enumerated)]
#[non_exhaustive]
pub enum ISO14823CodePictogramCodeServiceCategoryCodePublicFacilitiesPictogram {
publicFacilities = 0,
}
#[doc = " Inner type "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
#[rasn(enumerated)]
#[non_exhaustive]
pub enum ISO14823CodePictogramCodeServiceCategoryCodeAmbientOrRoadConditionPictogram {
ambientCondition = 0,
roadCondition = 1,
}
#[doc = " Inner type "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(choice, automatic_tags)]
#[non_exhaustive]
pub enum ISO14823CodePictogramCodeServiceCategoryCode {
trafficSignPictogram(ISO14823CodePictogramCodeServiceCategoryCodeTrafficSignPictogram),
publicFacilitiesPictogram(
ISO14823CodePictogramCodeServiceCategoryCodePublicFacilitiesPictogram,
),
ambientOrRoadConditionPictogram(
ISO14823CodePictogramCodeServiceCategoryCodeAmbientOrRoadConditionPictogram,
),
}
#[doc = " Inner type "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct ISO14823CodePictogramCodePictogramCategoryCode {
#[rasn(value("1..=9"))]
pub nature: u8,
#[rasn(value("0..=99"), identifier = "serialNumber")]
pub serial_number: u8,
}
impl ISO14823CodePictogramCodePictogramCategoryCode {
pub fn new(nature: u8, serial_number: u8) -> Self {
Self {
nature,
serial_number,
}
}
}
#[doc = " Inner type "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct ISO14823CodePictogramCode {
#[rasn(size("2"), identifier = "countryCode")]
pub country_code: Option<OctetString>,
#[rasn(identifier = "serviceCategoryCode")]
pub service_category_code: ISO14823CodePictogramCodeServiceCategoryCode,
#[rasn(identifier = "pictogramCategoryCode")]
pub pictogram_category_code: ISO14823CodePictogramCodePictogramCategoryCode,
}
impl ISO14823CodePictogramCode {
pub fn new(
country_code: Option<OctetString>,
service_category_code: ISO14823CodePictogramCodeServiceCategoryCode,
pictogram_category_code: ISO14823CodePictogramCodePictogramCategoryCode,
) -> Self {
Self {
country_code,
service_category_code,
pictogram_category_code,
}
}
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct ISO14823Code {
#[rasn(identifier = "pictogramCode")]
pub pictogram_code: ISO14823CodePictogramCode,
pub attributes: Option<ISO14823Attributes>,
}
impl ISO14823Code {
pub fn new(
pictogram_code: ISO14823CodePictogramCode,
attributes: Option<ISO14823Attributes>,
) -> Self {
Self {
pictogram_code,
attributes,
}
}
}
#[doc = "Definition of Containers"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(choice, automatic_tags)]
#[non_exhaustive]
pub enum IviContainer {
glc(GeographicLocationContainer),
giv(GeneralIviContainer),
rcc(RoadConfigurationContainer),
tc(TextContainer),
lac(LayoutContainer),
#[rasn(extension_addition)]
avc(AutomatedVehicleContainer),
#[rasn(extension_addition)]
mlc(MapLocationContainer),
#[rasn(extension_addition)]
rsc(RoadSurfaceContainer),
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=8", extensible))]
pub struct IviContainers(pub SequenceOf<IviContainer>);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("1..=32767", extensible))]
pub struct IviIdentificationNumber(pub Integer);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=8"))]
pub struct IviIdentificationNumbers(pub SequenceOf<IviIdentificationNumber>);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=1023"))]
pub struct IviLaneWidth(pub u16);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
#[non_exhaustive]
pub struct IviManagementContainer {
#[rasn(identifier = "serviceProviderId")]
pub service_provider_id: Provider,
#[rasn(identifier = "iviIdentificationNumber")]
pub ivi_identification_number: IviIdentificationNumber,
#[rasn(identifier = "timeStamp")]
pub time_stamp: Option<TimestampIts>,
#[rasn(identifier = "validFrom")]
pub valid_from: Option<TimestampIts>,
#[rasn(identifier = "validTo")]
pub valid_to: Option<TimestampIts>,
#[rasn(identifier = "connectedIviStructures")]
pub connected_ivi_structures: Option<IviIdentificationNumbers>,
#[rasn(identifier = "iviStatus")]
pub ivi_status: IviStatus,
#[rasn(extension_addition, identifier = "connectedDenms")]
pub connected_denms: Option<ConnectedDenms>,
}
impl IviManagementContainer {
pub fn new(
service_provider_id: Provider,
ivi_identification_number: IviIdentificationNumber,
time_stamp: Option<TimestampIts>,
valid_from: Option<TimestampIts>,
valid_to: Option<TimestampIts>,
connected_ivi_structures: Option<IviIdentificationNumbers>,
ivi_status: IviStatus,
connected_denms: Option<ConnectedDenms>,
) -> Self {
Self {
service_provider_id,
ivi_identification_number,
time_stamp,
valid_from,
valid_to,
connected_ivi_structures,
ivi_status,
connected_denms,
}
}
}
#[doc = " only renamed from V1, no change"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=3"))]
pub struct IviPurpose(pub u8);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=7"))]
pub struct IviStatus(pub u8);
#[doc = " Definition of IVI structure"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct IviStructure {
pub mandatory: IviManagementContainer,
pub optional: Option<IviContainers>,
}
impl IviStructure {
pub fn new(mandatory: IviManagementContainer, optional: Option<IviContainers>) -> Self {
Self {
mandatory,
optional,
}
}
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=7"))]
pub struct IviType(pub u8);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct LaneCharacteristics {
#[rasn(identifier = "zoneDefinitionAccuracy")]
pub zone_definition_accuracy: DefinitionAccuracy,
#[rasn(identifier = "existinglaneMarkingStatus")]
pub existinglane_marking_status: LaneMarkingStatus,
#[rasn(identifier = "newlaneMarkingColour")]
pub newlane_marking_colour: MarkingColour,
#[rasn(identifier = "laneDelimitationLeft")]
pub lane_delimitation_left: LaneDelimitation,
#[rasn(identifier = "laneDelimitationRight")]
pub lane_delimitation_right: LaneDelimitation,
#[rasn(identifier = "mergingWith")]
pub merging_with: Zid,
}
impl LaneCharacteristics {
pub fn new(
zone_definition_accuracy: DefinitionAccuracy,
existinglane_marking_status: LaneMarkingStatus,
newlane_marking_colour: MarkingColour,
lane_delimitation_left: LaneDelimitation,
lane_delimitation_right: LaneDelimitation,
merging_with: Zid,
) -> Self {
Self {
zone_definition_accuracy,
existinglane_marking_status,
newlane_marking_colour,
lane_delimitation_left,
lane_delimitation_right,
merging_with,
}
}
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=16", extensible))]
pub struct LaneConfiguration(pub SequenceOf<LaneInformation>);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=7", extensible))]
pub struct LaneDelimitation(pub Integer);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=16", extensible))]
pub struct LaneIds(pub SequenceOf<LaneID>);
#[doc = " Inner type "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct LaneInformationExtGroupDetectionZoneIds {
#[rasn(identifier = "detectionZoneIds")]
pub detection_zone_ids: Option<ZoneIds>,
#[rasn(identifier = "relevanceZoneIds")]
pub relevance_zone_ids: Option<ZoneIds>,
#[rasn(identifier = "laneCharacteristics")]
pub lane_characteristics: Option<LaneCharacteristics>,
#[rasn(identifier = "laneSurfaceStaticCharacteristics")]
pub lane_surface_static_characteristics: Option<RoadSurfaceStaticCharacteristics>,
#[rasn(identifier = "laneSurfaceDynamicCharacteristics")]
pub lane_surface_dynamic_characteristics: Option<RoadSurfaceDynamicCharacteristics>,
}
impl LaneInformationExtGroupDetectionZoneIds {
pub fn new(
detection_zone_ids: Option<ZoneIds>,
relevance_zone_ids: Option<ZoneIds>,
lane_characteristics: Option<LaneCharacteristics>,
lane_surface_static_characteristics: Option<RoadSurfaceStaticCharacteristics>,
lane_surface_dynamic_characteristics: Option<RoadSurfaceDynamicCharacteristics>,
) -> Self {
Self {
detection_zone_ids,
relevance_zone_ids,
lane_characteristics,
lane_surface_static_characteristics,
lane_surface_dynamic_characteristics,
}
}
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
#[non_exhaustive]
pub struct LaneInformation {
#[rasn(identifier = "laneNumber")]
pub lane_number: LanePosition,
pub direction: Direction,
pub validity: Option<InternationalSignApplicablePeriod>,
#[rasn(identifier = "laneType")]
pub lane_type: LaneType,
#[rasn(identifier = "laneTypeQualifier")]
pub lane_type_qualifier: Option<CompleteVehicleCharacteristics>,
#[rasn(identifier = "laneStatus")]
pub lane_status: LaneStatus,
#[rasn(identifier = "laneWidth")]
pub lane_width: Option<IviLaneWidth>,
#[rasn(extension_addition_group, identifier = "SEQUENCE")]
pub ext_group_detection_zone_ids: Option<LaneInformationExtGroupDetectionZoneIds>,
}
impl LaneInformation {
pub fn new(
lane_number: LanePosition,
direction: Direction,
validity: Option<InternationalSignApplicablePeriod>,
lane_type: LaneType,
lane_type_qualifier: Option<CompleteVehicleCharacteristics>,
lane_status: LaneStatus,
lane_width: Option<IviLaneWidth>,
ext_group_detection_zone_ids: Option<LaneInformationExtGroupDetectionZoneIds>,
) -> Self {
Self {
lane_number,
direction,
validity,
lane_type,
lane_type_qualifier,
lane_status,
lane_width,
ext_group_detection_zone_ids,
}
}
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
#[rasn(delegate)]
pub struct LaneMarkingStatus(pub bool);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=8", extensible))]
pub struct LanePositions(pub SequenceOf<LanePosition>);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=7", extensible))]
pub struct LaneStatus(pub Integer);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=31"))]
pub struct LaneType(pub u8);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct LayoutComponent {
#[rasn(value("1..=8", extensible), identifier = "layoutComponentId")]
pub layout_component_id: Integer,
#[rasn(value("10..=73"))]
pub height: u8,
#[rasn(value("10..=265"))]
pub width: u16,
#[rasn(value("10..=265"))]
pub x: u16,
#[rasn(value("10..=73"))]
pub y: u8,
#[rasn(value("0..=1"), identifier = "textScripting")]
pub text_scripting: u8,
}
impl LayoutComponent {
pub fn new(
layout_component_id: Integer,
height: u8,
width: u16,
x: u16,
y: u8,
text_scripting: u8,
) -> Self {
Self {
layout_component_id,
height,
width,
x,
y,
text_scripting,
}
}
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=4", extensible))]
pub struct LayoutComponents(pub SequenceOf<LayoutComponent>);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
#[non_exhaustive]
pub struct LayoutContainer {
#[rasn(value("1..=4", extensible), identifier = "layoutId")]
pub layout_id: Integer,
#[rasn(value("10..=73"))]
pub height: Option<u8>,
#[rasn(value("10..=265"))]
pub width: Option<u16>,
#[rasn(identifier = "layoutComponents")]
pub layout_components: LayoutComponents,
}
impl LayoutContainer {
pub fn new(
layout_id: Integer,
height: Option<u8>,
width: Option<u16>,
layout_components: LayoutComponents,
) -> Self {
Self {
layout_id,
height,
width,
layout_components,
}
}
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct LoadType {
#[rasn(identifier = "goodsType")]
pub goods_type: GoodsType,
#[rasn(identifier = "dangerousGoodsType")]
pub dangerous_goods_type: DangerousGoodsBasic,
#[rasn(identifier = "specialTransportType")]
pub special_transport_type: SpecialTransportType,
}
impl LoadType {
pub fn new(
goods_type: GoodsType,
dangerous_goods_type: DangerousGoodsBasic,
special_transport_type: SpecialTransportType,
) -> Self {
Self {
goods_type,
dangerous_goods_type,
special_transport_type,
}
}
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct MapLocationContainer {
pub reference: MapReference,
pub parts: MlcParts,
}
impl MapLocationContainer {
pub fn new(reference: MapReference, parts: MlcParts) -> Self {
Self { reference, parts }
}
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(choice, automatic_tags)]
pub enum MapReference {
roadsegment(RoadSegmentReferenceID),
intersection(IntersectionReferenceID),
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=7", extensible))]
pub struct MarkingColour(pub Integer);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=7", extensible))]
pub struct MaterialType(pub Integer);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("1..=64"))]
pub struct MaxLenghtOfPlatoon(pub u8);
#[doc = " new DE in V2"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("2..=64"))]
pub struct MaxNoOfVehicles(pub u8);
#[doc = " new container part in V2"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct MlcPart {
#[rasn(identifier = "zoneId")]
pub zone_id: Zid,
#[rasn(identifier = "laneIds")]
pub lane_ids: Option<LaneIds>,
}
impl MlcPart {
pub fn new(zone_id: Zid, lane_ids: Option<LaneIds>) -> Self {
Self { zone_id, lane_ids }
}
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=16", extensible))]
pub struct MlcParts(pub SequenceOf<MlcPart>);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
#[non_exhaustive]
pub struct PlatooningRule {
pub priority: PriorityLevel,
#[rasn(identifier = "allowedSaeAutomationLevels")]
pub allowed_sae_automation_levels: SaeAutomationLevels,
#[rasn(identifier = "maxNoOfVehicles")]
pub max_no_of_vehicles: Option<MaxNoOfVehicles>,
#[rasn(identifier = "maxLenghtOfPlatoon")]
pub max_lenght_of_platoon: Option<MaxLenghtOfPlatoon>,
#[rasn(identifier = "minGapBetweenVehicles")]
pub min_gap_between_vehicles: Option<GapBetweenVehicles>,
#[rasn(identifier = "platoonMaxSpeedLimit")]
pub platoon_max_speed_limit: Option<SpeedValue>,
#[rasn(identifier = "platoonMinSpeedLimit")]
pub platoon_min_speed_limit: Option<SpeedValue>,
#[rasn(identifier = "platoonSpeedRecommendation")]
pub platoon_speed_recommendation: Option<SpeedValue>,
#[rasn(identifier = "roadSignCodes")]
pub road_sign_codes: Option<RoadSignCodes>,
#[rasn(identifier = "extraText")]
pub extra_text: Option<ConstraintTextLines2>,
}
impl PlatooningRule {
pub fn new(
priority: PriorityLevel,
allowed_sae_automation_levels: SaeAutomationLevels,
max_no_of_vehicles: Option<MaxNoOfVehicles>,
max_lenght_of_platoon: Option<MaxLenghtOfPlatoon>,
min_gap_between_vehicles: Option<GapBetweenVehicles>,
platoon_max_speed_limit: Option<SpeedValue>,
platoon_min_speed_limit: Option<SpeedValue>,
platoon_speed_recommendation: Option<SpeedValue>,
road_sign_codes: Option<RoadSignCodes>,
extra_text: Option<ConstraintTextLines2>,
) -> Self {
Self {
priority,
allowed_sae_automation_levels,
max_no_of_vehicles,
max_lenght_of_platoon,
min_gap_between_vehicles,
platoon_max_speed_limit,
platoon_min_speed_limit,
platoon_speed_recommendation,
road_sign_codes,
extra_text,
}
}
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=5"))]
pub struct PlatooningRules(pub SequenceOf<PlatooningRule>);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(choice, automatic_tags)]
#[non_exhaustive]
pub enum PolygonalLine {
deltaPositions(DeltaPositions),
deltaPositionsWithAltitude(DeltaReferencePositions),
absolutePositions(AbsolutePositions),
absolutePositionsWithAltitude(AbsolutePositionsWAltitude),
}
#[doc = " new DE in V2"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=2"))]
pub struct PriorityLevel(pub u8);
#[doc = " new DE in V2"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=15"))]
pub struct RSCUnit(pub u8);
#[doc = " Inner type "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(choice, automatic_tags)]
#[non_exhaustive]
pub enum RSCodeCode {
viennaConvention(VcCode),
iso14823(ISO14823Code),
#[rasn(value("0..=65535"))]
itisCodes(u16),
anyCatalogue(AnyCatalogue),
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct RSCode {
#[rasn(value("1..=4", extensible), identifier = "layoutComponentId")]
pub layout_component_id: Option<Integer>,
pub code: RSCodeCode,
}
impl RSCode {
pub fn new(layout_component_id: Option<Integer>, code: RSCodeCode) -> Self {
Self {
layout_component_id,
code,
}
}
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
#[non_exhaustive]
pub struct RccPart {
#[rasn(identifier = "relevanceZoneIds")]
pub relevance_zone_ids: ZoneIds,
#[rasn(identifier = "roadType")]
pub road_type: RoadType,
#[rasn(identifier = "laneConfiguration")]
pub lane_configuration: LaneConfiguration,
}
impl RccPart {
pub fn new(
relevance_zone_ids: ZoneIds,
road_type: RoadType,
lane_configuration: LaneConfiguration,
) -> Self {
Self {
relevance_zone_ids,
road_type,
lane_configuration,
}
}
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=16", extensible))]
pub struct RoadConfigurationContainer(pub SequenceOf<RccPart>);
#[doc = " new DF in V2"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=4", extensible))]
pub struct RoadSignCodes(pub SequenceOf<RSCode>);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=16", extensible))]
pub struct RoadSurfaceContainer(pub SequenceOf<RscPart>);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct RoadSurfaceDynamicCharacteristics {
pub condition: Condition,
pub temperature: Temperature,
#[rasn(identifier = "iceOrWaterDepth")]
pub ice_or_water_depth: Depth,
pub treatment: TreatmentType,
}
impl RoadSurfaceDynamicCharacteristics {
pub fn new(
condition: Condition,
temperature: Temperature,
ice_or_water_depth: Depth,
treatment: TreatmentType,
) -> Self {
Self {
condition,
temperature,
ice_or_water_depth,
treatment,
}
}
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct RoadSurfaceStaticCharacteristics {
#[rasn(identifier = "frictionCoefficient")]
pub friction_coefficient: FrictionCoefficient,
pub material: MaterialType,
pub wear: WearLevel,
#[rasn(identifier = "avBankingAngle")]
pub av_banking_angle: BankingAngle,
}
impl RoadSurfaceStaticCharacteristics {
pub fn new(
friction_coefficient: FrictionCoefficient,
material: MaterialType,
wear: WearLevel,
av_banking_angle: BankingAngle,
) -> Self {
Self {
friction_coefficient,
material,
wear,
av_banking_angle,
}
}
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct RscPart {
#[rasn(identifier = "detectionZoneIds")]
pub detection_zone_ids: Option<ZoneIds>,
#[rasn(identifier = "relevanceZoneIds")]
pub relevance_zone_ids: ZoneIds,
pub direction: Option<Direction>,
#[rasn(identifier = "roadSurfaceStaticCharacteristics")]
pub road_surface_static_characteristics: Option<RoadSurfaceStaticCharacteristics>,
#[rasn(identifier = "roadSurfaceDynamicCharacteristics")]
pub road_surface_dynamic_characteristics: Option<RoadSurfaceDynamicCharacteristics>,
}
impl RscPart {
pub fn new(
detection_zone_ids: Option<ZoneIds>,
relevance_zone_ids: ZoneIds,
direction: Option<Direction>,
road_surface_static_characteristics: Option<RoadSurfaceStaticCharacteristics>,
road_surface_dynamic_characteristics: Option<RoadSurfaceDynamicCharacteristics>,
) -> Self {
Self {
detection_zone_ids,
relevance_zone_ids,
direction,
road_surface_static_characteristics,
road_surface_dynamic_characteristics,
}
}
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=5"))]
pub struct SaeAutomationLevel(pub u8);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=5"))]
pub struct SaeAutomationLevels(pub SequenceOf<SaeAutomationLevel>);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct Segment {
pub line: PolygonalLine,
#[rasn(identifier = "laneWidth")]
pub lane_width: Option<IviLaneWidth>,
}
impl Segment {
pub fn new(line: PolygonalLine, lane_width: Option<IviLaneWidth>) -> Self {
Self { line, lane_width }
}
}
#[doc = " Inner type "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct TcPartExtGroupIviType {
#[rasn(identifier = "iviType")]
pub ivi_type: IviType,
#[rasn(identifier = "laneStatus")]
pub lane_status: Option<LaneStatus>,
#[rasn(identifier = "vehicleCharacteristics")]
pub vehicle_characteristics: Option<VehicleCharacteristicsList>,
}
impl TcPartExtGroupIviType {
pub fn new(
ivi_type: IviType,
lane_status: Option<LaneStatus>,
vehicle_characteristics: Option<VehicleCharacteristicsList>,
) -> Self {
Self {
ivi_type,
lane_status,
vehicle_characteristics,
}
}
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
#[non_exhaustive]
pub struct TcPart {
#[rasn(identifier = "detectionZoneIds")]
pub detection_zone_ids: Option<ZoneIds>,
#[rasn(identifier = "relevanceZoneIds")]
pub relevance_zone_ids: ZoneIds,
pub direction: Option<Direction>,
#[rasn(identifier = "driverAwarenessZoneIds")]
pub driver_awareness_zone_ids: Option<ZoneIds>,
#[rasn(value("0..=255"), identifier = "minimumAwarenessTime")]
pub minimum_awareness_time: Option<u8>,
#[rasn(identifier = "applicableLanes")]
pub applicable_lanes: Option<LanePositions>,
#[rasn(value("1..=4", extensible), identifier = "layoutId")]
pub layout_id: Option<Integer>,
#[rasn(value("1..=64", extensible), identifier = "preStoredlayoutId")]
pub pre_storedlayout_id: Option<Integer>,
pub text: Option<TextLines>,
pub data: OctetString,
#[rasn(extension_addition_group, identifier = "SEQUENCE")]
pub ext_group_ivi_type: Option<TcPartExtGroupIviType>,
}
impl TcPart {
pub fn new(
detection_zone_ids: Option<ZoneIds>,
relevance_zone_ids: ZoneIds,
direction: Option<Direction>,
driver_awareness_zone_ids: Option<ZoneIds>,
minimum_awareness_time: Option<u8>,
applicable_lanes: Option<LanePositions>,
layout_id: Option<Integer>,
pre_storedlayout_id: Option<Integer>,
text: Option<TextLines>,
data: OctetString,
ext_group_ivi_type: Option<TcPartExtGroupIviType>,
) -> Self {
Self {
detection_zone_ids,
relevance_zone_ids,
direction,
driver_awareness_zone_ids,
minimum_awareness_time,
applicable_lanes,
layout_id,
pre_storedlayout_id,
text,
data,
ext_group_ivi_type,
}
}
}
#[doc = " new DE in V2"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("-100..=151"))]
pub struct Temperature(pub i16);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct Text {
#[rasn(value("1..=4", extensible), identifier = "layoutComponentId")]
pub layout_component_id: Option<Integer>,
#[rasn(size("10"))]
pub language: BitString,
#[rasn(identifier = "textContent")]
pub text_content: Utf8String,
}
impl Text {
pub fn new(
layout_component_id: Option<Integer>,
language: BitString,
text_content: Utf8String,
) -> Self {
Self {
layout_component_id,
language,
text_content,
}
}
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=16", extensible))]
pub struct TextContainer(pub SequenceOf<TcPart>);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=4", extensible))]
pub struct TextLines(pub SequenceOf<Text>);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct TractorCharacteristics {
#[rasn(identifier = "equalTo")]
pub equal_to: Option<VehicleCharacteristicsFixValuesList>,
#[rasn(identifier = "notEqualTo")]
pub not_equal_to: Option<VehicleCharacteristicsFixValuesList>,
pub ranges: Option<VehicleCharacteristicsRangesList>,
}
impl TractorCharacteristics {
pub fn new(
equal_to: Option<VehicleCharacteristicsFixValuesList>,
not_equal_to: Option<VehicleCharacteristicsFixValuesList>,
ranges: Option<VehicleCharacteristicsRangesList>,
) -> Self {
Self {
equal_to,
not_equal_to,
ranges,
}
}
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct TrailerCharacteristics {
#[rasn(identifier = "equalTo")]
pub equal_to: Option<TrailerCharacteristicsFixValuesList>,
#[rasn(identifier = "notEqualTo")]
pub not_equal_to: Option<TrailerCharacteristicsFixValuesList>,
pub ranges: Option<TrailerCharacteristicsRangesList>,
}
impl TrailerCharacteristics {
pub fn new(
equal_to: Option<TrailerCharacteristicsFixValuesList>,
not_equal_to: Option<TrailerCharacteristicsFixValuesList>,
ranges: Option<TrailerCharacteristicsRangesList>,
) -> Self {
Self {
equal_to,
not_equal_to,
ranges,
}
}
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=4", extensible))]
pub struct TrailerCharacteristicsFixValuesList(pub SequenceOf<VehicleCharacteristicsFixValues>);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=3"))]
pub struct TrailerCharacteristicsList(pub SequenceOf<TrailerCharacteristics>);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=4", extensible))]
pub struct TrailerCharacteristicsRangesList(pub SequenceOf<VehicleCharacteristicsRanges>);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate)]
pub struct TrainCharacteristics(pub TractorCharacteristics);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=7"))]
pub struct TreatmentType(pub u8);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=8", extensible))]
pub struct ValidityPeriods(pub SequenceOf<InternationalSignApplicablePeriod>);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=7"))]
pub struct VcClass(pub u8);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct VcCode {
#[rasn(identifier = "roadSignClass")]
pub road_sign_class: VcClass,
#[rasn(value("1..=64"), identifier = "roadSignCode")]
pub road_sign_code: u8,
#[rasn(identifier = "vcOption")]
pub vc_option: VcOption,
pub validity: Option<ValidityPeriods>,
#[rasn(value("0..=65535"))]
pub value: Option<u16>,
pub unit: Option<RSCUnit>,
}
impl VcCode {
pub fn new(
road_sign_class: VcClass,
road_sign_code: u8,
vc_option: VcOption,
validity: Option<ValidityPeriods>,
value: Option<u16>,
unit: Option<RSCUnit>,
) -> Self {
Self {
road_sign_class,
road_sign_code,
vc_option,
validity,
value,
unit,
}
}
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=7"))]
pub struct VcOption(pub u8);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(choice, automatic_tags)]
#[non_exhaustive]
pub enum VehicleCharacteristicsFixValues {
simpleVehicleType(StationType),
euVehicleCategoryCode(EuVehicleCategoryCode),
iso3833VehicleType(Iso3833VehicleType),
euroAndCo2value(EnvironmentalCharacteristics),
engineCharacteristics(EngineCharacteristics),
loadType(LoadType),
usage(VehicleRole),
}
#[doc = " new DF in V2"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=4", extensible))]
pub struct VehicleCharacteristicsFixValuesList(pub SequenceOf<VehicleCharacteristicsFixValues>);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=8", extensible))]
pub struct VehicleCharacteristicsList(pub SequenceOf<CompleteVehicleCharacteristics>);
#[doc = " Inner type "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(choice, automatic_tags)]
#[non_exhaustive]
pub enum VehicleCharacteristicsRangesLimits {
#[rasn(value("0..=7"))]
numberOfAxles(u8),
vehicleDimensions(VehicleDimensions),
vehicleWeightLimits(VehicleWeightLimits),
axleWeightLimits(AxleWeightLimits),
passengerCapacity(PassengerCapacity),
exhaustEmissionValues(ExhaustEmissionValues),
dieselEmissionValues(DieselEmissionValues),
soundLevel(SoundLevel),
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct VehicleCharacteristicsRanges {
#[rasn(identifier = "comparisonOperator")]
pub comparison_operator: ComparisonOperator,
pub limits: VehicleCharacteristicsRangesLimits,
}
impl VehicleCharacteristicsRanges {
pub fn new(
comparison_operator: ComparisonOperator,
limits: VehicleCharacteristicsRangesLimits,
) -> Self {
Self {
comparison_operator,
limits,
}
}
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=4", extensible))]
pub struct VehicleCharacteristicsRangesList(pub SequenceOf<VehicleCharacteristicsRanges>);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=7", extensible))]
pub struct WearLevel(pub Integer);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("1..=32", extensible))]
pub struct Zid(pub Integer);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(choice, automatic_tags)]
#[non_exhaustive]
pub enum Zone {
segment(Segment),
area(PolygonalLine),
computedSegment(ComputedSegment),
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=8", extensible))]
pub struct ZoneIds(pub SequenceOf<Zid>);
}
#[allow(
non_camel_case_types,
non_snake_case,
non_upper_case_globals,
unused,
clippy::too_many_arguments
)]
pub mod ivim_pdu_descriptions {
extern crate alloc;
use core::borrow::Borrow;
use rasn::prelude::*;
use super::super::cdd_1_3_1_1::its_container::ItsPduHeader;
use super::ivi::IviStructure;
#[doc = " In vehicle information Message Root"]
#[doc = " This DF includes DEs for the IVIM protocolVersion, the IVI message type identifier _messageID_,"]
#[doc = " the station identifier _stationID_ of the originating ITS-S and the IVI data from ISO TS 19321."]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct IVIM {
pub header: ItsPduHeader,
pub ivi: IviStructure,
}
impl IVIM {
pub fn new(header: ItsPduHeader, ivi: IviStructure) -> Self {
Self { header, ivi }
}
}
}