Trait SessionProxyInterface 

pub trait SessionProxyInterface: Send + Sync {
    type Read32ResponseFut: Future<Output = Result<SessionRead32Result, Error>> + Send;
    type SnapshotResponseFut: Future<Output = Result<SessionSnapshotResult, Error>> + Send;
    type ReadAuditResponseFut: Future<Output = Result<(Vec<AuditEntry>, bool, u64, u64), Error>> + Send;
    type Write32ResponseFut: Future<Output = Result<SessionWrite32Result, Error>> + Send;
    type Poll32ResponseFut: Future<Output = Result<SessionPoll32Result, Error>> + Send;
    type ExecuteSequenceResponseFut: Future<Output = Result<SessionExecuteSequenceResult, Error>> + Send;
    type GpioReadResponseFut: Future<Output = Result<SessionGpioReadResult, Error>> + Send;
    type GpioWriteResponseFut: Future<Output = Result<SessionGpioWriteResult, Error>> + Send;
    type I2cTransferResponseFut: Future<Output = Result<SessionI2cTransferResult, Error>> + Send;
    type SpiTransmitResponseFut: Future<Output = Result<SessionSpiTransmitResult, Error>> + Send;
    type OpenGpioResponseFut: Future<Output = Result<SessionOpenGpioResult, Error>> + Send;
    type OpenI2cResponseFut: Future<Output = Result<SessionOpenI2cResult, Error>> + Send;
    type OpenSpiResponseFut: Future<Output = Result<SessionOpenSpiResult, Error>> + Send;
    type WaitForInterruptResponseFut: Future<Output = Result<SessionWaitForInterruptResult, Error>> + Send;
    type ClockEnableResponseFut: Future<Output = Result<SessionClockEnableResult, Error>> + Send;
    type ClockDisableResponseFut: Future<Output = Result<SessionClockDisableResult, Error>> + Send;
    type ClockIsEnabledResponseFut: Future<Output = Result<SessionClockIsEnabledResult, Error>> + Send;
    type ClockSetRateResponseFut: Future<Output = Result<SessionClockSetRateResult, Error>> + Send;
    type ClockQueryRateResponseFut: Future<Output = Result<SessionClockQueryRateResult, Error>> + Send;
    type ClockGetRateResponseFut: Future<Output = Result<SessionClockGetRateResult, Error>> + Send;
    type ResetAssertResponseFut: Future<Output = Result<SessionResetAssertResult, Error>> + Send;
    type ResetDeassertResponseFut: Future<Output = Result<SessionResetDeassertResult, Error>> + Send;
    type ResetToggleResponseFut: Future<Output = Result<SessionResetToggleResult, Error>> + Send;
    type ResetStatusResponseFut: Future<Output = Result<SessionResetStatusResult, Error>> + Send;
    type SerialReadResponseFut: Future<Output = Result<SessionSerialReadResult, Error>> + Send;
    type SerialWriteResponseFut: Future<Output = Result<SessionSerialWriteResult, Error>> + Send;

    // Required methods
    fn read32(&self, resource: u32, offset: u64) -> Self::Read32ResponseFut;
    fn snapshot(&self, items: &[SnapshotItem]) -> Self::SnapshotResponseFut;
    fn read_audit(&self, cursor: u64, limit: u32) -> Self::ReadAuditResponseFut;
    fn write32(
        &self,
        resource: u32,
        offset: u64,
        value: u32,
        write_mask: u32,
        precondition: Option<&WritePrecondition>,
        readback: bool,
    ) -> Self::Write32ResponseFut;
    fn poll32(
        &self,
        resource: u32,
        offset: u64,
        expected: u32,
        mask: u32,
        interval_ns: i64,
        timeout_ns: i64,
    ) -> Self::Poll32ResponseFut;
    fn execute_sequence(
        &self,
        items: &[SequenceItem],
    ) -> Self::ExecuteSequenceResponseFut;
    fn gpio_read(&self, resource: u32) -> Self::GpioReadResponseFut;
    fn gpio_write(
        &self,
        resource: u32,
        value: bool,
    ) -> Self::GpioWriteResponseFut;
    fn i2c_transfer(
        &self,
        resource: u32,
        write_data: &[u8],
        read_length: u32,
    ) -> Self::I2cTransferResponseFut;
    fn spi_transmit(
        &self,
        resource: u32,
        tx_data: &[u8],
    ) -> Self::SpiTransmitResponseFut;
    fn open_gpio(
        &self,
        resource: u32,
        endpoint: ServerEnd<GpioEndpointMarker>,
    ) -> Self::OpenGpioResponseFut;
    fn open_i2c(
        &self,
        resource: u32,
        endpoint: ServerEnd<I2cEndpointMarker>,
    ) -> Self::OpenI2cResponseFut;
    fn open_spi(
        &self,
        resource: u32,
        endpoint: ServerEnd<SpiEndpointMarker>,
    ) -> Self::OpenSpiResponseFut;
    fn wait_for_interrupt(
        &self,
        resource: u32,
        after_sequence: u64,
        timeout_ns: i64,
    ) -> Self::WaitForInterruptResponseFut;
    fn clock_enable(&self, resource: u32) -> Self::ClockEnableResponseFut;
    fn clock_disable(&self, resource: u32) -> Self::ClockDisableResponseFut;
    fn clock_is_enabled(&self, resource: u32) -> Self::ClockIsEnabledResponseFut;
    fn clock_set_rate(
        &self,
        resource: u32,
        hz: u64,
    ) -> Self::ClockSetRateResponseFut;
    fn clock_query_rate(
        &self,
        resource: u32,
        hz_in: u64,
    ) -> Self::ClockQueryRateResponseFut;
    fn clock_get_rate(&self, resource: u32) -> Self::ClockGetRateResponseFut;
    fn reset_assert(&self, resource: u32) -> Self::ResetAssertResponseFut;
    fn reset_deassert(&self, resource: u32) -> Self::ResetDeassertResponseFut;
    fn reset_toggle(&self, resource: u32) -> Self::ResetToggleResponseFut;
    fn reset_status(&self, resource: u32) -> Self::ResetStatusResponseFut;
    fn serial_read(&self, resource: u32) -> Self::SerialReadResponseFut;
    fn serial_write(
        &self,
        resource: u32,
        data: &[u8],
    ) -> Self::SerialWriteResponseFut;
}

Required Associated Types

type Read32ResponseFut: Future<Output = Result<SessionRead32Result, Error>> + Send

type SnapshotResponseFut: Future<Output = Result<SessionSnapshotResult, Error>> + Send

type ReadAuditResponseFut: Future<Output = Result<(Vec<AuditEntry>, bool, u64, u64), Error>> + Send

type Write32ResponseFut: Future<Output = Result<SessionWrite32Result, Error>> + Send

type Poll32ResponseFut: Future<Output = Result<SessionPoll32Result, Error>> + Send

type ExecuteSequenceResponseFut: Future<Output = Result<SessionExecuteSequenceResult, Error>> + Send

type GpioReadResponseFut: Future<Output = Result<SessionGpioReadResult, Error>> + Send

type GpioWriteResponseFut: Future<Output = Result<SessionGpioWriteResult, Error>> + Send

type I2cTransferResponseFut: Future<Output = Result<SessionI2cTransferResult, Error>> + Send

type SpiTransmitResponseFut: Future<Output = Result<SessionSpiTransmitResult, Error>> + Send

type OpenGpioResponseFut: Future<Output = Result<SessionOpenGpioResult, Error>> + Send

type OpenI2cResponseFut: Future<Output = Result<SessionOpenI2cResult, Error>> + Send

type OpenSpiResponseFut: Future<Output = Result<SessionOpenSpiResult, Error>> + Send

type WaitForInterruptResponseFut: Future<Output = Result<SessionWaitForInterruptResult, Error>> + Send

type ClockEnableResponseFut: Future<Output = Result<SessionClockEnableResult, Error>> + Send

type ClockDisableResponseFut: Future<Output = Result<SessionClockDisableResult, Error>> + Send

type ClockIsEnabledResponseFut: Future<Output = Result<SessionClockIsEnabledResult, Error>> + Send

type ClockSetRateResponseFut: Future<Output = Result<SessionClockSetRateResult, Error>> + Send

type ClockQueryRateResponseFut: Future<Output = Result<SessionClockQueryRateResult, Error>> + Send

type ClockGetRateResponseFut: Future<Output = Result<SessionClockGetRateResult, Error>> + Send

type ResetAssertResponseFut: Future<Output = Result<SessionResetAssertResult, Error>> + Send

type ResetDeassertResponseFut: Future<Output = Result<SessionResetDeassertResult, Error>> + Send

type ResetToggleResponseFut: Future<Output = Result<SessionResetToggleResult, Error>> + Send

type ResetStatusResponseFut: Future<Output = Result<SessionResetStatusResult, Error>> + Send

type SerialReadResponseFut: Future<Output = Result<SessionSerialReadResult, Error>> + Send

type SerialWriteResponseFut: Future<Output = Result<SessionSerialWriteResult, Error>> + Send

Required Methods

fn read32(&self, resource: u32, offset: u64) -> Self::Read32ResponseFut

fn snapshot(&self, items: &[SnapshotItem]) -> Self::SnapshotResponseFut

fn read_audit(&self, cursor: u64, limit: u32) -> Self::ReadAuditResponseFut

fn write32( &self, resource: u32, offset: u64, value: u32, write_mask: u32, precondition: Option<&WritePrecondition>, readback: bool, ) -> Self::Write32ResponseFut

fn poll32( &self, resource: u32, offset: u64, expected: u32, mask: u32, interval_ns: i64, timeout_ns: i64, ) -> Self::Poll32ResponseFut

fn execute_sequence( &self, items: &[SequenceItem], ) -> Self::ExecuteSequenceResponseFut

fn gpio_read(&self, resource: u32) -> Self::GpioReadResponseFut

fn gpio_write(&self, resource: u32, value: bool) -> Self::GpioWriteResponseFut

fn i2c_transfer( &self, resource: u32, write_data: &[u8], read_length: u32, ) -> Self::I2cTransferResponseFut

fn spi_transmit( &self, resource: u32, tx_data: &[u8], ) -> Self::SpiTransmitResponseFut

fn open_gpio( &self, resource: u32, endpoint: ServerEnd<GpioEndpointMarker>, ) -> Self::OpenGpioResponseFut

fn open_i2c( &self, resource: u32, endpoint: ServerEnd<I2cEndpointMarker>, ) -> Self::OpenI2cResponseFut

fn open_spi( &self, resource: u32, endpoint: ServerEnd<SpiEndpointMarker>, ) -> Self::OpenSpiResponseFut

fn wait_for_interrupt( &self, resource: u32, after_sequence: u64, timeout_ns: i64, ) -> Self::WaitForInterruptResponseFut

fn clock_enable(&self, resource: u32) -> Self::ClockEnableResponseFut

fn clock_disable(&self, resource: u32) -> Self::ClockDisableResponseFut

fn clock_is_enabled(&self, resource: u32) -> Self::ClockIsEnabledResponseFut

fn clock_set_rate( &self, resource: u32, hz: u64, ) -> Self::ClockSetRateResponseFut

fn clock_query_rate( &self, resource: u32, hz_in: u64, ) -> Self::ClockQueryRateResponseFut

fn clock_get_rate(&self, resource: u32) -> Self::ClockGetRateResponseFut

fn reset_assert(&self, resource: u32) -> Self::ResetAssertResponseFut

fn reset_deassert(&self, resource: u32) -> Self::ResetDeassertResponseFut

fn reset_toggle(&self, resource: u32) -> Self::ResetToggleResponseFut

fn reset_status(&self, resource: u32) -> Self::ResetStatusResponseFut

fn serial_read(&self, resource: u32) -> Self::SerialReadResponseFut

fn serial_write( &self, resource: u32, data: &[u8], ) -> Self::SerialWriteResponseFut

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

impl SessionProxyInterface for SessionProxy

type Read32ResponseFut = QueryResponseFut<Result<(u32, u64, i64), OperationError>>

type SnapshotResponseFut = QueryResponseFut<Result<(Vec<SnapshotItemResult>, bool), OperationError>>

type ReadAuditResponseFut = QueryResponseFut<(Vec<AuditEntry>, bool, u64, u64)>

type Write32ResponseFut = QueryResponseFut<Result<(u32, u64, i64), OperationError>>

type Poll32ResponseFut = QueryResponseFut<Result<(u32, u64, i64), OperationError>>

type ExecuteSequenceResponseFut = QueryResponseFut<Result<(Vec<SequenceItemResult>, bool), OperationError>>

type GpioReadResponseFut = QueryResponseFut<Result<(bool, u64, i64), OperationError>>

type GpioWriteResponseFut = QueryResponseFut<Result<(u64, i64), OperationError>>

type I2cTransferResponseFut = QueryResponseFut<Result<(Vec<u8>, u64, i64), OperationError>>

type SpiTransmitResponseFut = QueryResponseFut<Result<(Vec<u8>, u64, i64), OperationError>>

type OpenGpioResponseFut = QueryResponseFut<Result<(), OperationError>>

type OpenI2cResponseFut = QueryResponseFut<Result<(), OperationError>>

type OpenSpiResponseFut = QueryResponseFut<Result<(), OperationError>>

type WaitForInterruptResponseFut = QueryResponseFut<Result<(u32, u64, u64, i64, u64), OperationError>>

type ClockEnableResponseFut = QueryResponseFut<Result<(u64, i64), OperationError>>

type ClockDisableResponseFut = QueryResponseFut<Result<(u64, i64), OperationError>>

type ClockIsEnabledResponseFut = QueryResponseFut<Result<(bool, u64, i64), OperationError>>

type ClockSetRateResponseFut = QueryResponseFut<Result<(u64, i64), OperationError>>

type ClockQueryRateResponseFut = QueryResponseFut<Result<(u64, u64, i64), OperationError>>

type ClockGetRateResponseFut = QueryResponseFut<Result<(u64, u64, i64), OperationError>>

type ResetAssertResponseFut = QueryResponseFut<Result<(u64, i64), OperationError>>

type ResetDeassertResponseFut = QueryResponseFut<Result<(u64, i64), OperationError>>

type ResetToggleResponseFut = QueryResponseFut<Result<(u64, i64), OperationError>>

type ResetStatusResponseFut = QueryResponseFut<Result<(bool, u64, i64), OperationError>>

type SerialReadResponseFut = QueryResponseFut<Result<(Vec<u8>, u64, i64), OperationError>>

type SerialWriteResponseFut = QueryResponseFut<Result<(u64, i64), OperationError>>