Struct LogicCase

pub struct LogicCase<'a> {

    pub case01: Option<u8>,
    pub case02: Option<u8>,
    pub case03: Option<u8>,
    pub case04: Option<u8>,
    pub case05: Option<u8>,
    pub case06: Option<u8>,
    pub case07: Option<u8>,
    pub case08: Option<u8>,
    pub case09: Option<u8>,
    pub case10: Option<u8>,
    pub case11: Option<u8>,
    pub case12: Option<u8>,
    pub case13: Option<u8>,
    pub case14: Option<u8>,
    pub case15: Option<u8>,
    pub case16: Option<u8>,
    pub oncase01: &'a str,
    pub oncase02: &'a str,
    pub oncase03: &'a str,
    pub oncase04: &'a str,
    pub oncase05: Option<&'a str>,
    pub oncase06: Option<&'a str>,
    pub oncase07: Option<&'a str>,
    pub oncase08: Option<&'a str>,
    pub oncase09: Option<&'a str>,
    pub oncase10: Option<&'a str>,
    pub oncase11: Option<&'a str>,
    pub oncase12: Option<&'a str>,
    pub oncase13: Option<&'a str>,
    pub oncase14: Option<&'a str>,
    pub oncase15: Option<&'a str>,
    pub oncase16: Option<&'a str>,
    pub origin: Vector,
    pub targetname: &'a str,
}

Fields

case01: Option<u8>

case02: Option<u8>

case03: Option<u8>

case04: Option<u8>

case05: Option<u8>

case06: Option<u8>

case07: Option<u8>

case08: Option<u8>

case09: Option<u8>

case10: Option<u8>

case11: Option<u8>

case12: Option<u8>

case13: Option<u8>

case14: Option<u8>

case15: Option<u8>

case16: Option<u8>

oncase01: &'a str

oncase02: &'a str

oncase03: &'a str

oncase04: &'a str

oncase05: Option<&'a str>

oncase06: Option<&'a str>

oncase07: Option<&'a str>

oncase08: Option<&'a str>

oncase09: Option<&'a str>

oncase10: Option<&'a str>

oncase11: Option<&'a str>

oncase12: Option<&'a str>

oncase13: Option<&'a str>

oncase14: Option<&'a str>

oncase15: Option<&'a str>

oncase16: Option<&'a str>

origin: Vector

targetname: &'a str

Trait Implementations

impl<'a> Clone for LogicCase<'a>

fn clone(&self) -> LogicCase<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for LogicCase<'a>

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

Formats the value using the given formatter.

impl<'de: 'a, 'a> Deserialize<'de> for LogicCase<'a>

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.