Struct Machine

pub struct Machine {

    pub name: String,
    pub source_file: Option<String>,
    pub rom_of: Option<String>,
    pub clone_of: Option<String>,
    pub is_bios: Option<bool>,
    pub is_device: Option<bool>,
    pub runnable: Option<bool>,
    pub is_mechanical: Option<bool>,
    pub sample_of: Option<String>,
    pub description: Option<String>,
    pub year: Option<String>,
    pub manufacturer: Option<String>,
    pub bios_sets: Vec<BiosSet>,
    pub roms: Vec<Rom>,
    pub device_refs: Vec<DeviceRef>,
    pub software_list: Vec<Software>,
    pub samples: Vec<Sample>,
    pub driver_status: Option<String>,
    pub languages: Vec<String>,
    pub players: Option<String>,
    pub series: Option<String>,
    pub category: Option<String>,
    pub subcategory: Option<String>,
    pub is_mature: Option<bool>,
    pub history_sections: Vec<HistorySection>,
    pub disks: Vec<Disk>,
    pub extended_data: Option<ExtendedData>,
    pub resources: Vec<Resource>,
}

MAME machine, including all relevant metadata and resources.

The Machine struct stores detailed information about a specific MAME machine, including its configuration, associated ROMs, BIOS sets, devices, and other related metadata. This structure is used in parsing, processing, and exporting MAME-related data.

Fields

name: String

The name of the machine.

source_file: Option<String>

The source file associated with the machine (optional).

rom_of: Option<String>

Specifies the ROM that this machine is a variant of (optional).

clone_of: Option<String>

Specifies the parent machine if this is a clone (optional).

is_bios: Option<bool>

Indicates if the machine is a BIOS set (optional).

is_device: Option<bool>

Indicates if the machine is a device (optional).

runnable: Option<bool>

Indicates if the machine is runnable (optional).

is_mechanical: Option<bool>

Indicates if the machine is mechanical (optional).

sample_of: Option<String>

Specifies the sample set associated with the machine (optional).

description: Option<String>

A description of the machine (optional).

year: Option<String>

The year the machine was released (optional).

manufacturer: Option<String>

The manufacturer of the machine (optional).

bios_sets: Vec<BiosSet>

A list of BIOS sets associated with the machine.

roms: Vec<Rom>

A list of ROMs required by the machine.

device_refs: Vec<DeviceRef>

A list of device references associated with the machine.

software_list: Vec<Software>

A list of software lists associated with the machine.

samples: Vec<Sample>

A list of samples used by the machine.

driver_status: Option<String>

The driver status of the machine (optional).

languages: Vec<String>

A list of supported languages for the machine.

players: Option<String>

Indicates the number of players supported (optional).

series: Option<String>

The series to which the machine belongs (optional).

category: Option<String>

The category of the machine (optional).

subcategory: Option<String>

The subcategory of the machine (optional).

is_mature: Option<bool>

Indicates if the machine contains mature content (optional).

history_sections: Vec<HistorySection>

A list of history sections associated with the machine.

disks: Vec<Disk>

A list of disk data associated with the machine.

extended_data: Option<ExtendedData>

Additional normalized data not present in the original MAME data (optional).

resources: Vec<Resource>

A list of external resources, such as images and videos, associated with the machine.

Implementations

impl Machine

pub fn new(name: String) -> Self

Creates a new Machine instance with the specified name.

pub fn combine(&mut self, other: &Machine)

Combines the metadata of this machine with another machine.

Trait Implementations

impl Clone for Machine

fn clone(&self) -> Machine

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Machine

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Machine

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Machine

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.