Trait FDomainProxyInterface

pub trait FDomainProxyInterface: Send + Sync {
    type CreateChannelResponseFut: Future<Output = Result<ChannelCreateChannelResult, Error>> + Send;
    type ReadChannelResponseFut: Future<Output = Result<ChannelReadChannelResult, Error>> + Send;
    type WriteChannelResponseFut: Future<Output = Result<ChannelWriteChannelResult, Error>> + Send;
    type ReadChannelStreamingStartResponseFut: Future<Output = Result<ChannelReadChannelStreamingStartResult, Error>> + Send;
    type ReadChannelStreamingStopResponseFut: Future<Output = Result<ChannelReadChannelStreamingStopResult, Error>> + Send;
    type CreateEventResponseFut: Future<Output = Result<EventCreateEventResult, Error>> + Send;
    type CreateEventPairResponseFut: Future<Output = Result<EventPairCreateEventPairResult, Error>> + Send;
    type CreateSocketResponseFut: Future<Output = Result<SocketCreateSocketResult, Error>> + Send;
    type SetSocketDispositionResponseFut: Future<Output = Result<SocketSetSocketDispositionResult, Error>> + Send;
    type ReadSocketResponseFut: Future<Output = Result<SocketReadSocketResult, Error>> + Send;
    type WriteSocketResponseFut: Future<Output = Result<SocketWriteSocketResult, Error>> + Send;
    type ReadSocketStreamingStartResponseFut: Future<Output = Result<SocketReadSocketStreamingStartResult, Error>> + Send;
    type ReadSocketStreamingStopResponseFut: Future<Output = Result<SocketReadSocketStreamingStopResult, Error>> + Send;
    type NamespaceResponseFut: Future<Output = Result<FDomainNamespaceResult, Error>> + Send;
    type CloseResponseFut: Future<Output = Result<FDomainCloseResult, Error>> + Send;
    type DuplicateResponseFut: Future<Output = Result<FDomainDuplicateResult, Error>> + Send;
    type ReplaceResponseFut: Future<Output = Result<FDomainReplaceResult, Error>> + Send;
    type SignalResponseFut: Future<Output = Result<FDomainSignalResult, Error>> + Send;
    type SignalPeerResponseFut: Future<Output = Result<FDomainSignalPeerResult, Error>> + Send;
    type WaitForSignalsResponseFut: Future<Output = Result<FDomainWaitForSignalsResult, Error>> + Send;
    type AcknowledgeWriteErrorResponseFut: Future<Output = Result<FDomainAcknowledgeWriteErrorResult, Error>> + Send;

    // Required methods
    fn create_channel(
        &self,
        handles: &[NewHid; 2],
    ) -> Self::CreateChannelResponseFut;
    fn read_channel(&self, handle: &Hid) -> Self::ReadChannelResponseFut;
    fn write_channel(
        &self,
        handle: &Hid,
        data: &[u8],
        handles: &Handles,
    ) -> Self::WriteChannelResponseFut;
    fn read_channel_streaming_start(
        &self,
        handle: &Hid,
    ) -> Self::ReadChannelStreamingStartResponseFut;
    fn read_channel_streaming_stop(
        &self,
        handle: &Hid,
    ) -> Self::ReadChannelStreamingStopResponseFut;
    fn create_event(&self, handle: &NewHid) -> Self::CreateEventResponseFut;
    fn create_event_pair(
        &self,
        handles: &[NewHid; 2],
    ) -> Self::CreateEventPairResponseFut;
    fn create_socket(
        &self,
        options: SocketType,
        handles: &[NewHid; 2],
    ) -> Self::CreateSocketResponseFut;
    fn set_socket_disposition(
        &self,
        handle: &Hid,
        disposition: SocketDisposition,
        disposition_peer: SocketDisposition,
    ) -> Self::SetSocketDispositionResponseFut;
    fn read_socket(
        &self,
        handle: &Hid,
        max_bytes: u64,
    ) -> Self::ReadSocketResponseFut;
    fn write_socket(
        &self,
        handle: &Hid,
        data: &[u8],
    ) -> Self::WriteSocketResponseFut;
    fn read_socket_streaming_start(
        &self,
        handle: &Hid,
    ) -> Self::ReadSocketStreamingStartResponseFut;
    fn read_socket_streaming_stop(
        &self,
        handle: &Hid,
    ) -> Self::ReadSocketStreamingStopResponseFut;
    fn namespace(&self, new_handle: &NewHid) -> Self::NamespaceResponseFut;
    fn close(&self, handles: &[Hid]) -> Self::CloseResponseFut;
    fn duplicate(
        &self,
        handle: &Hid,
        new_handle: &NewHid,
        rights: Rights,
    ) -> Self::DuplicateResponseFut;
    fn replace(
        &self,
        handle: &Hid,
        new_handle: &NewHid,
        rights: Rights,
    ) -> Self::ReplaceResponseFut;
    fn signal(
        &self,
        handle: &Hid,
        set: u32,
        clear: u32,
    ) -> Self::SignalResponseFut;
    fn signal_peer(
        &self,
        handle: &Hid,
        set: u32,
        clear: u32,
    ) -> Self::SignalPeerResponseFut;
    fn wait_for_signals(
        &self,
        handle: &Hid,
        signals: u32,
    ) -> Self::WaitForSignalsResponseFut;
    fn acknowledge_write_error(
        &self,
        handle: &Hid,
    ) -> Self::AcknowledgeWriteErrorResponseFut;
}

Required Associated Types

type CreateChannelResponseFut: Future<Output = Result<ChannelCreateChannelResult, Error>> + Send

type ReadChannelResponseFut: Future<Output = Result<ChannelReadChannelResult, Error>> + Send

type WriteChannelResponseFut: Future<Output = Result<ChannelWriteChannelResult, Error>> + Send

type ReadChannelStreamingStartResponseFut: Future<Output = Result<ChannelReadChannelStreamingStartResult, Error>> + Send

type ReadChannelStreamingStopResponseFut: Future<Output = Result<ChannelReadChannelStreamingStopResult, Error>> + Send

type CreateEventResponseFut: Future<Output = Result<EventCreateEventResult, Error>> + Send

type CreateEventPairResponseFut: Future<Output = Result<EventPairCreateEventPairResult, Error>> + Send

type CreateSocketResponseFut: Future<Output = Result<SocketCreateSocketResult, Error>> + Send

type SetSocketDispositionResponseFut: Future<Output = Result<SocketSetSocketDispositionResult, Error>> + Send

type ReadSocketResponseFut: Future<Output = Result<SocketReadSocketResult, Error>> + Send

type WriteSocketResponseFut: Future<Output = Result<SocketWriteSocketResult, Error>> + Send

type ReadSocketStreamingStartResponseFut: Future<Output = Result<SocketReadSocketStreamingStartResult, Error>> + Send

type ReadSocketStreamingStopResponseFut: Future<Output = Result<SocketReadSocketStreamingStopResult, Error>> + Send

type NamespaceResponseFut: Future<Output = Result<FDomainNamespaceResult, Error>> + Send

type CloseResponseFut: Future<Output = Result<FDomainCloseResult, Error>> + Send

type DuplicateResponseFut: Future<Output = Result<FDomainDuplicateResult, Error>> + Send

type ReplaceResponseFut: Future<Output = Result<FDomainReplaceResult, Error>> + Send

type SignalResponseFut: Future<Output = Result<FDomainSignalResult, Error>> + Send

type SignalPeerResponseFut: Future<Output = Result<FDomainSignalPeerResult, Error>> + Send

type WaitForSignalsResponseFut: Future<Output = Result<FDomainWaitForSignalsResult, Error>> + Send

type AcknowledgeWriteErrorResponseFut: Future<Output = Result<FDomainAcknowledgeWriteErrorResult, Error>> + Send

Required Methods

fn create_channel( &self, handles: &[NewHid; 2], ) -> Self::CreateChannelResponseFut

fn read_channel(&self, handle: &Hid) -> Self::ReadChannelResponseFut

fn write_channel( &self, handle: &Hid, data: &[u8], handles: &Handles, ) -> Self::WriteChannelResponseFut

fn read_channel_streaming_start( &self, handle: &Hid, ) -> Self::ReadChannelStreamingStartResponseFut

fn read_channel_streaming_stop( &self, handle: &Hid, ) -> Self::ReadChannelStreamingStopResponseFut

fn create_event(&self, handle: &NewHid) -> Self::CreateEventResponseFut

fn create_event_pair( &self, handles: &[NewHid; 2], ) -> Self::CreateEventPairResponseFut

fn create_socket( &self, options: SocketType, handles: &[NewHid; 2], ) -> Self::CreateSocketResponseFut

fn set_socket_disposition( &self, handle: &Hid, disposition: SocketDisposition, disposition_peer: SocketDisposition, ) -> Self::SetSocketDispositionResponseFut

fn read_socket( &self, handle: &Hid, max_bytes: u64, ) -> Self::ReadSocketResponseFut

fn write_socket( &self, handle: &Hid, data: &[u8], ) -> Self::WriteSocketResponseFut

fn read_socket_streaming_start( &self, handle: &Hid, ) -> Self::ReadSocketStreamingStartResponseFut

fn read_socket_streaming_stop( &self, handle: &Hid, ) -> Self::ReadSocketStreamingStopResponseFut

fn namespace(&self, new_handle: &NewHid) -> Self::NamespaceResponseFut

fn close(&self, handles: &[Hid]) -> Self::CloseResponseFut

fn duplicate( &self, handle: &Hid, new_handle: &NewHid, rights: Rights, ) -> Self::DuplicateResponseFut

fn replace( &self, handle: &Hid, new_handle: &NewHid, rights: Rights, ) -> Self::ReplaceResponseFut

fn signal(&self, handle: &Hid, set: u32, clear: u32) -> Self::SignalResponseFut

fn signal_peer( &self, handle: &Hid, set: u32, clear: u32, ) -> Self::SignalPeerResponseFut

fn wait_for_signals( &self, handle: &Hid, signals: u32, ) -> Self::WaitForSignalsResponseFut

fn acknowledge_write_error( &self, handle: &Hid, ) -> Self::AcknowledgeWriteErrorResponseFut

Implementors

impl FDomainProxyInterface for FDomainProxy

type CreateChannelResponseFut = QueryResponseFut<Result<(), Error>>

type ReadChannelResponseFut = QueryResponseFut<Result<(Vec<u8>, Vec<HandleInfo>), Error>>

type WriteChannelResponseFut = QueryResponseFut<Result<(), WriteChannelError>>

type ReadChannelStreamingStartResponseFut = QueryResponseFut<Result<(), Error>>

type ReadChannelStreamingStopResponseFut = QueryResponseFut<Result<(), Error>>

type CreateEventResponseFut = QueryResponseFut<Result<(), Error>>

type CreateEventPairResponseFut = QueryResponseFut<Result<(), Error>>

type CreateSocketResponseFut = QueryResponseFut<Result<(), Error>>

type SetSocketDispositionResponseFut = QueryResponseFut<Result<(), Error>>

type ReadSocketResponseFut = QueryResponseFut<Result<Vec<u8>, Error>>

type WriteSocketResponseFut = QueryResponseFut<Result<u64, WriteSocketError>>

type ReadSocketStreamingStartResponseFut = QueryResponseFut<Result<(), Error>>

type ReadSocketStreamingStopResponseFut = QueryResponseFut<Result<(), Error>>

type NamespaceResponseFut = QueryResponseFut<Result<(), Error>>

type CloseResponseFut = QueryResponseFut<Result<(), Error>>

type DuplicateResponseFut = QueryResponseFut<Result<(), Error>>

type ReplaceResponseFut = QueryResponseFut<Result<(), Error>>

type SignalResponseFut = QueryResponseFut<Result<(), Error>>

type SignalPeerResponseFut = QueryResponseFut<Result<(), Error>>

type WaitForSignalsResponseFut = QueryResponseFut<Result<u32, Error>>

type AcknowledgeWriteErrorResponseFut = QueryResponseFut<Result<(), Error>>