Enum CombineOp 

#[non_exhaustive]
pub enum CombineOp {
    Replace,
    Add,
}

The combine operation for an overlay composition (composition_rule = 0x02).

Selects how a correction member’s value at a covered index combines with the value shown by lower-precedence members (down to the base).

Examples

use hurray_core::layout::CombineOp;

assert_eq!(CombineOp::Replace.wire_byte(), 0x01);
assert_eq!(CombineOp::Add.wire_byte(), 0x02);
assert_eq!(CombineOp::from_wire(0x01), Some(CombineOp::Replace));
assert_eq!(CombineOp::from_wire(0x00), None);

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Replace

Last-wins: the topmost (latest-emitted) member covering an index wins within its box, and the base shows through elsewhere. Wire byte 0x01.

Add

The value at an index is the base value plus the sum of all covering corrections’ values at that index. Wire byte 0x02.

Implementations

impl CombineOp

pub fn wire_byte(self) -> u8

Returns the wire byte for this combine operation.

Examples

use hurray_core::layout::CombineOp;

assert_eq!(CombineOp::Replace.wire_byte(), 0x01);

pub fn from_wire(byte: u8) -> Option<Self>

Constructs a CombineOp from its wire byte. Returns None for any value other than 0x01 or 0x02.

Examples

use hurray_core::layout::CombineOp;

assert_eq!(CombineOp::from_wire(0x02), Some(CombineOp::Add));
assert_eq!(CombineOp::from_wire(0xFF), None);

Trait Implementations

impl Clone for CombineOp

fn clone(&self) -> CombineOp

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for CombineOp

impl Debug for CombineOp

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

Formats the value using the given formatter.

impl Eq for CombineOp

impl Hash for CombineOp

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for CombineOp

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl StructuralPartialEq for CombineOp