Trait FancyInput 

pub trait FancyInput {
    type Item: Clone + HasModulus;

    // Required methods
    fn encode_many(
        &mut self,
        values: &[u16],
        moduli: &[u16],
        channel: &mut Channel<'_>,
    ) -> Result<Vec<Self::Item>>;
    fn receive_many(
        &mut self,
        moduli: &[u16],
        channel: &mut Channel<'_>,
    ) -> Result<Vec<Self::Item>>;

    // Provided methods
    fn encode(
        &mut self,
        value: u16,
        modulus: u16,
        channel: &mut Channel<'_>,
    ) -> Result<Self::Item> { ... }
    fn receive(
        &mut self,
        modulus: u16,
        channel: &mut Channel<'_>,
    ) -> Result<Self::Item> { ... }
    fn encode_bundle(
        &mut self,
        values: &[u16],
        moduli: &[u16],
        channel: &mut Channel<'_>,
    ) -> Result<Bundle<Self::Item>> { ... }
    fn receive_bundle(
        &mut self,
        moduli: &[u16],
        channel: &mut Channel<'_>,
    ) -> Result<Bundle<Self::Item>> { ... }
    fn encode_bundles(
        &mut self,
        values: &[Vec<u16>],
        moduli: &[Vec<u16>],
        channel: &mut Channel<'_>,
    ) -> Result<Vec<Bundle<Self::Item>>> { ... }
    fn receive_many_bundles(
        &mut self,
        moduli: &[Vec<u16>],
        channel: &mut Channel<'_>,
    ) -> Result<Vec<Bundle<Self::Item>>> { ... }
    fn crt_encode(
        &mut self,
        value: u128,
        modulus: u128,
        channel: &mut Channel<'_>,
    ) -> Result<CrtBundle<Self::Item>> { ... }
    fn crt_receive(
        &mut self,
        modulus: u128,
        channel: &mut Channel<'_>,
    ) -> Result<CrtBundle<Self::Item>> { ... }
    fn crt_encode_many(
        &mut self,
        values: &[u128],
        modulus: u128,
        channel: &mut Channel<'_>,
    ) -> Result<Vec<CrtBundle<Self::Item>>> { ... }
    fn crt_receive_many(
        &mut self,
        n: usize,
        modulus: u128,
        channel: &mut Channel<'_>,
    ) -> Result<Vec<CrtBundle<Self::Item>>> { ... }
    fn bin_encode(
        &mut self,
        value: u128,
        nbits: usize,
        channel: &mut Channel<'_>,
    ) -> Result<BinaryBundle<Self::Item>> { ... }
    fn bin_receive(
        &mut self,
        nbits: usize,
        channel: &mut Channel<'_>,
    ) -> Result<BinaryBundle<Self::Item>> { ... }
    fn bin_encode_many(
        &mut self,
        values: &[u128],
        nbits: usize,
        channel: &mut Channel<'_>,
    ) -> Result<Vec<BinaryBundle<Self::Item>>> { ... }
    fn bin_receive_many(
        &mut self,
        ninputs: usize,
        nbits: usize,
        channel: &mut Channel<'_>,
    ) -> Result<Vec<BinaryBundle<Self::Item>>> { ... }
}

Convenience functions for encoding input to Fancy objects.

Required Associated Types

type Item: Clone + HasModulus

The type that this Fancy object operates over.

Required Methods

fn encode_many( &mut self, values: &[u16], moduli: &[u16], channel: &mut Channel<'_>, ) -> Result<Vec<Self::Item>>

Encode many values where the actual input is known.

When writing a garbler, the return value must correspond to the zero wire label.

fn receive_many( &mut self, moduli: &[u16], channel: &mut Channel<'_>, ) -> Result<Vec<Self::Item>>

Receive many values where the input is not known.

Provided Methods

fn encode( &mut self, value: u16, modulus: u16, channel: &mut Channel<'_>, ) -> Result<Self::Item>

Encode a single value.

When writing a garbler, the return value must correspond to the zero wire label.

fn receive( &mut self, modulus: u16, channel: &mut Channel<'_>, ) -> Result<Self::Item>

Receive a single value.

fn encode_bundle( &mut self, values: &[u16], moduli: &[u16], channel: &mut Channel<'_>, ) -> Result<Bundle<Self::Item>>

Encode a bundle.

fn receive_bundle( &mut self, moduli: &[u16], channel: &mut Channel<'_>, ) -> Result<Bundle<Self::Item>>

Receive a bundle.

fn encode_bundles( &mut self, values: &[Vec<u16>], moduli: &[Vec<u16>], channel: &mut Channel<'_>, ) -> Result<Vec<Bundle<Self::Item>>>

Encode many input bundles.

Panics,

Panics if values and moduli are of unequal length.

fn receive_many_bundles( &mut self, moduli: &[Vec<u16>], channel: &mut Channel<'_>, ) -> Result<Vec<Bundle<Self::Item>>>

Receive many input bundles.

fn crt_encode( &mut self, value: u128, modulus: u128, channel: &mut Channel<'_>, ) -> Result<CrtBundle<Self::Item>>

Encode a CRT input bundle.

fn crt_receive( &mut self, modulus: u128, channel: &mut Channel<'_>, ) -> Result<CrtBundle<Self::Item>>

Receive an CRT input bundle.

fn crt_encode_many( &mut self, values: &[u128], modulus: u128, channel: &mut Channel<'_>, ) -> Result<Vec<CrtBundle<Self::Item>>>

Encode many CRT input bundles.

fn crt_receive_many( &mut self, n: usize, modulus: u128, channel: &mut Channel<'_>, ) -> Result<Vec<CrtBundle<Self::Item>>>

Receive many CRT input bundles.

fn bin_encode( &mut self, value: u128, nbits: usize, channel: &mut Channel<'_>, ) -> Result<BinaryBundle<Self::Item>>

Encode a binary input bundle.

fn bin_receive( &mut self, nbits: usize, channel: &mut Channel<'_>, ) -> Result<BinaryBundle<Self::Item>>

Receive an binary input bundle.

fn bin_encode_many( &mut self, values: &[u128], nbits: usize, channel: &mut Channel<'_>, ) -> Result<Vec<BinaryBundle<Self::Item>>>

Encode many binary input bundles.

fn bin_receive_many( &mut self, ninputs: usize, nbits: usize, channel: &mut Channel<'_>, ) -> Result<Vec<BinaryBundle<Self::Item>>>

Receive many binary input bundles.

Implementors

impl FancyInput for CircuitAnalyzer

type Item = AnalyzerItem

impl FancyInput for Dummy

type Item = DummyVal

impl<F: Fancy + FancyInput<Item = <F as Fancy>::Item>> FancyInput for Informer<F>

type Item = <F as Fancy>::Item

impl<RNG: CryptoRng + RngCore, Wire: WireLabel> FancyInput for Garbler<RNG, Wire>

type Item = Wire

impl<Wire: BinaryWireLabel> FancyInput for Evaluator<Wire>

type Item = Wire