Trait lay::Layer[−][src]

pub trait Layer {
    type Operation;
    type Qubit;
    type Slot;
    type Buffer: Measured<Slot = Self::Slot>;
    type Requested;
    type Response;
    fn send(&mut self, ops: &[Self::Operation]) -> Self::Requested;

    fn receive(&mut self, buf: &mut Self::Buffer) -> Self::Response;

    fn make_buffer(&self) -> Self::Buffer;

    fn send_receive(
        &mut self, 
        ops: &[Self::Operation], 
        buf: &mut Self::Buffer
    ) -> Self::Response { ... }

    fn opsvec(&self) -> OpsVec<Self> { ... }
}

Associated Types

type Operation[src]

type Qubit[src]

type Slot[src]

type Buffer: Measured<Slot = Self::Slot>[src]

type Requested[src]

type Response[src]

Loading content...

Required methods

fn send(&mut self, ops: &[Self::Operation]) -> Self::Requested[src]

fn receive(&mut self, buf: &mut Self::Buffer) -> Self::Response[src]

fn make_buffer(&self) -> Self::Buffer[src]

Loading content...

Provided methods

fn send_receive(
    &mut self,
    ops: &[Self::Operation],
    buf: &mut Self::Buffer
) -> Self::Response[src]

fn opsvec(&self) -> OpsVec<Self>[src]

Loading content...

Implementors

impl<L: Layer, F: Fn(&mut L, &[L::Operation]) -> L::Requested, G: Fn(&mut L, &mut L::Buffer) -> L::Response, H: Fn(&mut L, &[L::Operation], &mut L::Buffer) -> L::Response> Layer for InjectLayer<L, F, G, H>[src]

type Operation = InjectOperation<L, F, G, H>

type Qubit = L::Qubit

type Slot = L::Slot

type Buffer = L::Buffer

type Requested = L::Requested

type Response = L::Response

impl<L: Layer, Q, S, C> Layer for QubitSlotConvertLayer<L, Q, S, C> where
    C: Converter<Q, L::Qubit, S, L::Slot>, [src]

type Operation = QubitSlotConvertOperation<L, Q, S, C>

type Qubit = Q

type Slot = S

type Buffer = QubitSlotConvertLayerBuffer<Self, L, C>

type Requested = L::Requested

type Response = L::Response

Loading content...