Enum ni::common::BinOp

pub enum BinOp {
    None {
        x: Operand,
        y: Operand,
    },
    First {
        x: Operand,
        y: Operand,
        offset: Operand,
    },
    Second {
        x: Operand,
        y: Operand,
        offset: Operand,
    },
    Both {
        x: Operand,
        y: Operand,
        offset: Operand,
    },
}

Variants

None

Fields of None

x: Operandy: Operand

First

Fields of First

x: Operandy: Operandoffset: Operand

Second

Fields of Second

x: Operandy: Operandoffset: Operand

Both

Fields of Both

x: Operandy: Operandoffset: Operand

Implementations

impl BinOp

pub fn new(x: Operand, y: Operand) -> Self

pub fn with_first(self, offset: Operand) -> Self

pub fn with_second(self, offset: Operand) -> Self

pub fn with_both(self, offset: Operand) -> Self

pub fn variant(&self) -> Variant

Trait Implementations

impl Clone for BinOp

fn clone(&self) -> BinOp

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for BinOp

impl Debug for BinOp

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

Formats the value using the given formatter.

impl Decode<Variant> for BinOp

type Err = DecodeError

fn decode<R>(bytes: &mut R, var: Variant) -> Result<Self, Self::Err> where
    R: Read, 

impl Encode for BinOp

type Err = EncodeError

fn encode<W>(&self, buf: &mut W) -> Result<(), Self::Err> where
    W: Write, 

impl Eq for BinOp

impl PartialEq<BinOp> for BinOp

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

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

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

This method tests for !=.

impl StructuralEq for BinOp

impl StructuralPartialEq for BinOp