Struct a2lfile::Module

pub struct Module {

    pub name: String,
    pub long_identifier: String,
    pub a2ml: Option<A2ml>,
    pub axis_pts: Vec<AxisPts>,
    pub blob: Vec<Blob>,
    pub characteristic: Vec<Characteristic>,
    pub compu_method: Vec<CompuMethod>,
    pub compu_tab: Vec<CompuTab>,
    pub compu_vtab: Vec<CompuVtab>,
    pub compu_vtab_range: Vec<CompuVtabRange>,
    pub frame: Vec<Frame>,
    pub function: Vec<Function>,
    pub group: Vec<Group>,
    pub if_data: Vec<IfData>,
    pub instance: Vec<Instance>,
    pub measurement: Vec<Measurement>,
    pub mod_common: Option<ModCommon>,
    pub mod_par: Option<ModPar>,
    pub record_layout: Vec<RecordLayout>,
    pub transformer: Vec<Transformer>,
    pub typedef_axis: Vec<TypedefAxis>,
    pub typedef_blob: Vec<TypedefBlob>,
    pub typedef_characteristic: Vec<TypedefCharacteristic>,
    pub typedef_measurement: Vec<TypedefMeasurement>,
    pub typedef_structure: Vec<TypedefStructure>,
    pub unit: Vec<Unit>,
    pub user_rights: Vec<UserRights>,
    pub variant_coding: Option<VariantCoding>,
    /* private fields */
}

The MODULE keyword describes a complete ECU or device with all adjustable and measurement objects, conversion methods and functions

At least one module must be defined within the PROJECT

Fields

name: String

long_identifier: String

a2ml: Option<A2ml>

axis_pts: Vec<AxisPts>

blob: Vec<Blob>

characteristic: Vec<Characteristic>

compu_method: Vec<CompuMethod>

compu_tab: Vec<CompuTab>

compu_vtab: Vec<CompuVtab>

compu_vtab_range: Vec<CompuVtabRange>

frame: Vec<Frame>

function: Vec<Function>

group: Vec<Group>

if_data: Vec<IfData>

instance: Vec<Instance>

measurement: Vec<Measurement>

mod_common: Option<ModCommon>

mod_par: Option<ModPar>

record_layout: Vec<RecordLayout>

transformer: Vec<Transformer>

typedef_axis: Vec<TypedefAxis>

typedef_blob: Vec<TypedefBlob>

typedef_characteristic: Vec<TypedefCharacteristic>

typedef_measurement: Vec<TypedefMeasurement>

typedef_structure: Vec<TypedefStructure>

unit: Vec<Unit>

user_rights: Vec<UserRights>

variant_coding: Option<VariantCoding>

Implementations

impl Module

pub fn new(name: String, long_identifier: String) -> Self

impl Module

pub fn build_namemap(&self) -> ModuleNameMap<'_>

build a map of all named elements inside the module

pub fn merge(&mut self, other: &mut Module)

merge another module with this module

Any elements in other that are not present in this module will be moved over. The other module will typically be empty at the end of the merge.

Trait Implementations

impl A2lObject<(u32, u32)> for Module

fn get_layout(&self) -> &BlockInfo<(u32, u32)>

get a reference to the BlockInfo that describes the layout of the a2l object

fn get_layout_mut(&mut self) -> &mut BlockInfo<(u32, u32)>

get a mutable reference to the BlockInfo that describes the layout of the a2l object

fn reset_location(&mut self)

reset the location information on the a2l object. It will be treated like a new object when writing a file

fn merge_includes(&mut self)

reset the reference to an include file on this objct and its children. This causes the object to be written into the output file instead of referenced through /include “filename”

fn get_line(&self) -> u32

get the source line number from which the current a2l object was loaded. Returns 0 if the object was newly created and not loaded from a file

impl A2lObjectName for Module

fn get_name(&self) -> &str

get the name of an a2l object. this trait is only implemented for those objects that have names, which is a subset of all objects

impl Clone for Module

fn clone(&self) -> Module

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Module

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for Module

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.