Trait CheckOk 

pub trait CheckOk {
    type Ok;

    // Required method
    fn check_ok(self) -> Result<Self::Ok, Error>;
}

Trait for verifying validity at runtime, upgrading the typestate to OkState.

Required Associated Types

type Ok

Required Methods

fn check_ok(self) -> Result<Self::Ok, Error>

Dyn Compatibility

This trait is dyn compatible.

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

Implementations on Foreign Types

impl<S> CheckOk for AcceptConnectionRequestCommand<S, CompleteState>

where S: Storage,

type Ok = AcceptConnectionRequestCommand<S, OkState>

fn check_ok( self, ) -> Result<<AcceptConnectionRequestCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AcceptConnectionRequestCommand<S, OkState>

where S: Storage,

type Ok = AcceptConnectionRequestCommand<S, OkState>

fn check_ok( self, ) -> Result<<AcceptConnectionRequestCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AcceptConnectionRequestCommand<S>

where S: Storage,

type Ok = AcceptConnectionRequestCommand<S, OkState>

fn check_ok( self, ) -> Result<<AcceptConnectionRequestCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for AcceptConnectionRequestCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = AcceptConnectionRequestCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<AcceptConnectionRequestCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AcceptConnectionRequestCommandWriter<S, OkState>

where S: MutStorage,

type Ok = AcceptConnectionRequestCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<AcceptConnectionRequestCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AcceptConnectionRequestCommandWriter<S>

where S: MutStorage,

type Ok = AcceptConnectionRequestCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<AcceptConnectionRequestCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for AclDataFrame<S, CompleteState>

where S: Storage,

type Ok = AclDataFrame<S, OkState>

fn check_ok( self, ) -> Result<<AclDataFrame<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AclDataFrame<S, OkState>

where S: Storage,

type Ok = AclDataFrame<S, OkState>

fn check_ok(self) -> Result<<AclDataFrame<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AclDataFrame<S>

where S: Storage,

type Ok = AclDataFrame<S, OkState>

fn check_ok(self) -> Result<<AclDataFrame<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for AclDataFrameHeader<S, CompleteState>

where S: Storage,

type Ok = AclDataFrameHeader<S, OkState>

fn check_ok( self, ) -> Result<<AclDataFrameHeader<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AclDataFrameHeader<S, OkState>

where S: Storage,

type Ok = AclDataFrameHeader<S, OkState>

fn check_ok( self, ) -> Result<<AclDataFrameHeader<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AclDataFrameHeader<S>

where S: Storage,

type Ok = AclDataFrameHeader<S, OkState>

fn check_ok(self) -> Result<<AclDataFrameHeader<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for AclDataFrameHeaderWriter<S, CompleteState>

where S: MutStorage,

type Ok = AclDataFrameHeaderWriter<S, OkState>

fn check_ok( self, ) -> Result<<AclDataFrameHeaderWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AclDataFrameHeaderWriter<S, OkState>

where S: MutStorage,

type Ok = AclDataFrameHeaderWriter<S, OkState>

fn check_ok( self, ) -> Result<<AclDataFrameHeaderWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AclDataFrameHeaderWriter<S>

where S: MutStorage,

type Ok = AclDataFrameHeaderWriter<S, OkState>

fn check_ok(self) -> Result<<AclDataFrameHeaderWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for AclDataFrameHeader_EmbossReservedAnonymousField4<S, CompleteState>

where S: Storage,

type Ok = AclDataFrameHeader_EmbossReservedAnonymousField4<S, OkState>

fn check_ok( self, ) -> Result<<AclDataFrameHeader_EmbossReservedAnonymousField4<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AclDataFrameHeader_EmbossReservedAnonymousField4<S, OkState>

where S: Storage,

type Ok = AclDataFrameHeader_EmbossReservedAnonymousField4<S, OkState>

fn check_ok( self, ) -> Result<<AclDataFrameHeader_EmbossReservedAnonymousField4<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AclDataFrameHeader_EmbossReservedAnonymousField4<S>

where S: Storage,

type Ok = AclDataFrameHeader_EmbossReservedAnonymousField4<S, OkState>

fn check_ok( self, ) -> Result<<AclDataFrameHeader_EmbossReservedAnonymousField4<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for AclDataFrameHeader_EmbossReservedAnonymousField4Writer<S, CompleteState>

where S: MutStorage,

type Ok = AclDataFrameHeader_EmbossReservedAnonymousField4Writer<S, OkState>

fn check_ok( self, ) -> Result<<AclDataFrameHeader_EmbossReservedAnonymousField4Writer<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AclDataFrameHeader_EmbossReservedAnonymousField4Writer<S, OkState>

where S: MutStorage,

type Ok = AclDataFrameHeader_EmbossReservedAnonymousField4Writer<S, OkState>

fn check_ok( self, ) -> Result<<AclDataFrameHeader_EmbossReservedAnonymousField4Writer<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AclDataFrameHeader_EmbossReservedAnonymousField4Writer<S>

where S: MutStorage,

type Ok = AclDataFrameHeader_EmbossReservedAnonymousField4Writer<S, OkState>

fn check_ok( self, ) -> Result<<AclDataFrameHeader_EmbossReservedAnonymousField4Writer<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for AclDataFrameWriter<S, CompleteState>

where S: MutStorage,

type Ok = AclDataFrameWriter<S, OkState>

fn check_ok( self, ) -> Result<<AclDataFrameWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AclDataFrameWriter<S, OkState>

where S: MutStorage,

type Ok = AclDataFrameWriter<S, OkState>

fn check_ok( self, ) -> Result<<AclDataFrameWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AclDataFrameWriter<S>

where S: MutStorage,

type Ok = AclDataFrameWriter<S, OkState>

fn check_ok(self) -> Result<<AclDataFrameWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttErrorRsp<S, CompleteState>

where S: Storage,

type Ok = AttErrorRsp<S, OkState>

fn check_ok( self, ) -> Result<<AttErrorRsp<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttErrorRsp<S, OkState>

where S: Storage,

type Ok = AttErrorRsp<S, OkState>

fn check_ok(self) -> Result<<AttErrorRsp<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttErrorRsp<S>

where S: Storage,

type Ok = AttErrorRsp<S, OkState>

fn check_ok(self) -> Result<<AttErrorRsp<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttErrorRspWriter<S, CompleteState>

where S: MutStorage,

type Ok = AttErrorRspWriter<S, OkState>

fn check_ok( self, ) -> Result<<AttErrorRspWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttErrorRspWriter<S, OkState>

where S: MutStorage,

type Ok = AttErrorRspWriter<S, OkState>

fn check_ok( self, ) -> Result<<AttErrorRspWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttErrorRspWriter<S>

where S: MutStorage,

type Ok = AttErrorRspWriter<S, OkState>

fn check_ok(self) -> Result<<AttErrorRspWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttExchangeMtuReq<S, CompleteState>

where S: Storage,

type Ok = AttExchangeMtuReq<S, OkState>

fn check_ok( self, ) -> Result<<AttExchangeMtuReq<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttExchangeMtuReq<S, OkState>

where S: Storage,

type Ok = AttExchangeMtuReq<S, OkState>

fn check_ok( self, ) -> Result<<AttExchangeMtuReq<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttExchangeMtuReq<S>

where S: Storage,

type Ok = AttExchangeMtuReq<S, OkState>

fn check_ok(self) -> Result<<AttExchangeMtuReq<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttExchangeMtuReqWriter<S, CompleteState>

where S: MutStorage,

type Ok = AttExchangeMtuReqWriter<S, OkState>

fn check_ok( self, ) -> Result<<AttExchangeMtuReqWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttExchangeMtuReqWriter<S, OkState>

where S: MutStorage,

type Ok = AttExchangeMtuReqWriter<S, OkState>

fn check_ok( self, ) -> Result<<AttExchangeMtuReqWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttExchangeMtuReqWriter<S>

where S: MutStorage,

type Ok = AttExchangeMtuReqWriter<S, OkState>

fn check_ok(self) -> Result<<AttExchangeMtuReqWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttExchangeMtuRsp<S, CompleteState>

where S: Storage,

type Ok = AttExchangeMtuRsp<S, OkState>

fn check_ok( self, ) -> Result<<AttExchangeMtuRsp<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttExchangeMtuRsp<S, OkState>

where S: Storage,

type Ok = AttExchangeMtuRsp<S, OkState>

fn check_ok( self, ) -> Result<<AttExchangeMtuRsp<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttExchangeMtuRsp<S>

where S: Storage,

type Ok = AttExchangeMtuRsp<S, OkState>

fn check_ok(self) -> Result<<AttExchangeMtuRsp<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttExchangeMtuRspWriter<S, CompleteState>

where S: MutStorage,

type Ok = AttExchangeMtuRspWriter<S, OkState>

fn check_ok( self, ) -> Result<<AttExchangeMtuRspWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttExchangeMtuRspWriter<S, OkState>

where S: MutStorage,

type Ok = AttExchangeMtuRspWriter<S, OkState>

fn check_ok( self, ) -> Result<<AttExchangeMtuRspWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttExchangeMtuRspWriter<S>

where S: MutStorage,

type Ok = AttExchangeMtuRspWriter<S, OkState>

fn check_ok(self) -> Result<<AttExchangeMtuRspWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttExecuteWriteReq<S, CompleteState>

where S: Storage,

type Ok = AttExecuteWriteReq<S, OkState>

fn check_ok( self, ) -> Result<<AttExecuteWriteReq<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttExecuteWriteReq<S, OkState>

where S: Storage,

type Ok = AttExecuteWriteReq<S, OkState>

fn check_ok( self, ) -> Result<<AttExecuteWriteReq<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttExecuteWriteReq<S>

where S: Storage,

type Ok = AttExecuteWriteReq<S, OkState>

fn check_ok(self) -> Result<<AttExecuteWriteReq<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttExecuteWriteReqWriter<S, CompleteState>

where S: MutStorage,

type Ok = AttExecuteWriteReqWriter<S, OkState>

fn check_ok( self, ) -> Result<<AttExecuteWriteReqWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttExecuteWriteReqWriter<S, OkState>

where S: MutStorage,

type Ok = AttExecuteWriteReqWriter<S, OkState>

fn check_ok( self, ) -> Result<<AttExecuteWriteReqWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttExecuteWriteReqWriter<S>

where S: MutStorage,

type Ok = AttExecuteWriteReqWriter<S, OkState>

fn check_ok(self) -> Result<<AttExecuteWriteReqWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttFindByTypeValueReqHeader<S, CompleteState>

where S: Storage,

type Ok = AttFindByTypeValueReqHeader<S, OkState>

fn check_ok( self, ) -> Result<<AttFindByTypeValueReqHeader<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttFindByTypeValueReqHeader<S, OkState>

where S: Storage,

type Ok = AttFindByTypeValueReqHeader<S, OkState>

fn check_ok( self, ) -> Result<<AttFindByTypeValueReqHeader<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttFindByTypeValueReqHeader<S>

where S: Storage,

type Ok = AttFindByTypeValueReqHeader<S, OkState>

fn check_ok( self, ) -> Result<<AttFindByTypeValueReqHeader<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttFindByTypeValueReqHeaderWriter<S, CompleteState>

where S: MutStorage,

type Ok = AttFindByTypeValueReqHeaderWriter<S, OkState>

fn check_ok( self, ) -> Result<<AttFindByTypeValueReqHeaderWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttFindByTypeValueReqHeaderWriter<S, OkState>

where S: MutStorage,

type Ok = AttFindByTypeValueReqHeaderWriter<S, OkState>

fn check_ok( self, ) -> Result<<AttFindByTypeValueReqHeaderWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttFindByTypeValueReqHeaderWriter<S>

where S: MutStorage,

type Ok = AttFindByTypeValueReqHeaderWriter<S, OkState>

fn check_ok( self, ) -> Result<<AttFindByTypeValueReqHeaderWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttFindInformationReq<S, CompleteState>

where S: Storage,

type Ok = AttFindInformationReq<S, OkState>

fn check_ok( self, ) -> Result<<AttFindInformationReq<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttFindInformationReq<S, OkState>

where S: Storage,

type Ok = AttFindInformationReq<S, OkState>

fn check_ok( self, ) -> Result<<AttFindInformationReq<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttFindInformationReq<S>

where S: Storage,

type Ok = AttFindInformationReq<S, OkState>

fn check_ok(self) -> Result<<AttFindInformationReq<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttFindInformationReqWriter<S, CompleteState>

where S: MutStorage,

type Ok = AttFindInformationReqWriter<S, OkState>

fn check_ok( self, ) -> Result<<AttFindInformationReqWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttFindInformationReqWriter<S, OkState>

where S: MutStorage,

type Ok = AttFindInformationReqWriter<S, OkState>

fn check_ok( self, ) -> Result<<AttFindInformationReqWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttFindInformationReqWriter<S>

where S: MutStorage,

type Ok = AttFindInformationReqWriter<S, OkState>

fn check_ok( self, ) -> Result<<AttFindInformationReqWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttFindInformationRspHeader<S, CompleteState>

where S: Storage,

type Ok = AttFindInformationRspHeader<S, OkState>

fn check_ok( self, ) -> Result<<AttFindInformationRspHeader<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttFindInformationRspHeader<S, OkState>

where S: Storage,

type Ok = AttFindInformationRspHeader<S, OkState>

fn check_ok( self, ) -> Result<<AttFindInformationRspHeader<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttFindInformationRspHeader<S>

where S: Storage,

type Ok = AttFindInformationRspHeader<S, OkState>

fn check_ok( self, ) -> Result<<AttFindInformationRspHeader<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttFindInformationRspHeaderWriter<S, CompleteState>

where S: MutStorage,

type Ok = AttFindInformationRspHeaderWriter<S, OkState>

fn check_ok( self, ) -> Result<<AttFindInformationRspHeaderWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttFindInformationRspHeaderWriter<S, OkState>

where S: MutStorage,

type Ok = AttFindInformationRspHeaderWriter<S, OkState>

fn check_ok( self, ) -> Result<<AttFindInformationRspHeaderWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttFindInformationRspHeaderWriter<S>

where S: MutStorage,

type Ok = AttFindInformationRspHeaderWriter<S, OkState>

fn check_ok( self, ) -> Result<<AttFindInformationRspHeaderWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttHandleValueIndHeader<S, CompleteState>

where S: Storage,

type Ok = AttHandleValueIndHeader<S, OkState>

fn check_ok( self, ) -> Result<<AttHandleValueIndHeader<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttHandleValueIndHeader<S, OkState>

where S: Storage,

type Ok = AttHandleValueIndHeader<S, OkState>

fn check_ok( self, ) -> Result<<AttHandleValueIndHeader<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttHandleValueIndHeader<S>

where S: Storage,

type Ok = AttHandleValueIndHeader<S, OkState>

fn check_ok(self) -> Result<<AttHandleValueIndHeader<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttHandleValueIndHeaderWriter<S, CompleteState>

where S: MutStorage,

type Ok = AttHandleValueIndHeaderWriter<S, OkState>

fn check_ok( self, ) -> Result<<AttHandleValueIndHeaderWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttHandleValueIndHeaderWriter<S, OkState>

where S: MutStorage,

type Ok = AttHandleValueIndHeaderWriter<S, OkState>

fn check_ok( self, ) -> Result<<AttHandleValueIndHeaderWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttHandleValueIndHeaderWriter<S>

where S: MutStorage,

type Ok = AttHandleValueIndHeaderWriter<S, OkState>

fn check_ok( self, ) -> Result<<AttHandleValueIndHeaderWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttHandleValueNtf<S, CompleteState>

where S: Storage,

type Ok = AttHandleValueNtf<S, OkState>

fn check_ok( self, ) -> Result<<AttHandleValueNtf<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttHandleValueNtf<S, OkState>

where S: Storage,

type Ok = AttHandleValueNtf<S, OkState>

fn check_ok( self, ) -> Result<<AttHandleValueNtf<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttHandleValueNtf<S>

where S: Storage,

type Ok = AttHandleValueNtf<S, OkState>

fn check_ok(self) -> Result<<AttHandleValueNtf<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttHandleValueNtfHeader<S, CompleteState>

where S: Storage,

type Ok = AttHandleValueNtfHeader<S, OkState>

fn check_ok( self, ) -> Result<<AttHandleValueNtfHeader<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttHandleValueNtfHeader<S, OkState>

where S: Storage,

type Ok = AttHandleValueNtfHeader<S, OkState>

fn check_ok( self, ) -> Result<<AttHandleValueNtfHeader<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttHandleValueNtfHeader<S>

where S: Storage,

type Ok = AttHandleValueNtfHeader<S, OkState>

fn check_ok(self) -> Result<<AttHandleValueNtfHeader<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttHandleValueNtfHeaderWriter<S, CompleteState>

where S: MutStorage,

type Ok = AttHandleValueNtfHeaderWriter<S, OkState>

fn check_ok( self, ) -> Result<<AttHandleValueNtfHeaderWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttHandleValueNtfHeaderWriter<S, OkState>

where S: MutStorage,

type Ok = AttHandleValueNtfHeaderWriter<S, OkState>

fn check_ok( self, ) -> Result<<AttHandleValueNtfHeaderWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttHandleValueNtfHeaderWriter<S>

where S: MutStorage,

type Ok = AttHandleValueNtfHeaderWriter<S, OkState>

fn check_ok( self, ) -> Result<<AttHandleValueNtfHeaderWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttHandleValueNtfWriter<S, CompleteState>

where S: MutStorage,

type Ok = AttHandleValueNtfWriter<S, OkState>

fn check_ok( self, ) -> Result<<AttHandleValueNtfWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttHandleValueNtfWriter<S, OkState>

where S: MutStorage,

type Ok = AttHandleValueNtfWriter<S, OkState>

fn check_ok( self, ) -> Result<<AttHandleValueNtfWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttHandleValueNtfWriter<S>

where S: MutStorage,

type Ok = AttHandleValueNtfWriter<S, OkState>

fn check_ok(self) -> Result<<AttHandleValueNtfWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttHandlesInformation<S, CompleteState>

where S: Storage,

type Ok = AttHandlesInformation<S, OkState>

fn check_ok( self, ) -> Result<<AttHandlesInformation<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttHandlesInformation<S, OkState>

where S: Storage,

type Ok = AttHandlesInformation<S, OkState>

fn check_ok( self, ) -> Result<<AttHandlesInformation<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttHandlesInformation<S>

where S: Storage,

type Ok = AttHandlesInformation<S, OkState>

fn check_ok(self) -> Result<<AttHandlesInformation<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttHandlesInformationWriter<S, CompleteState>

where S: MutStorage,

type Ok = AttHandlesInformationWriter<S, OkState>

fn check_ok( self, ) -> Result<<AttHandlesInformationWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttHandlesInformationWriter<S, OkState>

where S: MutStorage,

type Ok = AttHandlesInformationWriter<S, OkState>

fn check_ok( self, ) -> Result<<AttHandlesInformationWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttHandlesInformationWriter<S>

where S: MutStorage,

type Ok = AttHandlesInformationWriter<S, OkState>

fn check_ok( self, ) -> Result<<AttHandlesInformationWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttHeader<S, CompleteState>

where S: Storage,

type Ok = AttHeader<S, OkState>

fn check_ok(self) -> Result<<AttHeader<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttHeader<S, OkState>

where S: Storage,

type Ok = AttHeader<S, OkState>

fn check_ok(self) -> Result<<AttHeader<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttHeader<S>

where S: Storage,

type Ok = AttHeader<S, OkState>

fn check_ok(self) -> Result<<AttHeader<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttHeaderWriter<S, CompleteState>

where S: MutStorage,

type Ok = AttHeaderWriter<S, OkState>

fn check_ok( self, ) -> Result<<AttHeaderWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttHeaderWriter<S, OkState>

where S: MutStorage,

type Ok = AttHeaderWriter<S, OkState>

fn check_ok(self) -> Result<<AttHeaderWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttHeaderWriter<S>

where S: MutStorage,

type Ok = AttHeaderWriter<S, OkState>

fn check_ok(self) -> Result<<AttHeaderWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttInformationData16<S, CompleteState>

where S: Storage,

type Ok = AttInformationData16<S, OkState>

fn check_ok( self, ) -> Result<<AttInformationData16<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttInformationData16<S, OkState>

where S: Storage,

type Ok = AttInformationData16<S, OkState>

fn check_ok( self, ) -> Result<<AttInformationData16<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttInformationData16<S>

where S: Storage,

type Ok = AttInformationData16<S, OkState>

fn check_ok(self) -> Result<<AttInformationData16<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttInformationData16Writer<S, CompleteState>

where S: MutStorage,

type Ok = AttInformationData16Writer<S, OkState>

fn check_ok( self, ) -> Result<<AttInformationData16Writer<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttInformationData16Writer<S, OkState>

where S: MutStorage,

type Ok = AttInformationData16Writer<S, OkState>

fn check_ok( self, ) -> Result<<AttInformationData16Writer<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttInformationData16Writer<S>

where S: MutStorage,

type Ok = AttInformationData16Writer<S, OkState>

fn check_ok( self, ) -> Result<<AttInformationData16Writer<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttInformationData128<S, CompleteState>

where S: Storage,

type Ok = AttInformationData128<S, OkState>

fn check_ok( self, ) -> Result<<AttInformationData128<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttInformationData128<S, OkState>

where S: Storage,

type Ok = AttInformationData128<S, OkState>

fn check_ok( self, ) -> Result<<AttInformationData128<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttInformationData128<S>

where S: Storage,

type Ok = AttInformationData128<S, OkState>

fn check_ok(self) -> Result<<AttInformationData128<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttInformationData128Writer<S, CompleteState>

where S: MutStorage,

type Ok = AttInformationData128Writer<S, OkState>

fn check_ok( self, ) -> Result<<AttInformationData128Writer<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttInformationData128Writer<S, OkState>

where S: MutStorage,

type Ok = AttInformationData128Writer<S, OkState>

fn check_ok( self, ) -> Result<<AttInformationData128Writer<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttInformationData128Writer<S>

where S: MutStorage,

type Ok = AttInformationData128Writer<S, OkState>

fn check_ok( self, ) -> Result<<AttInformationData128Writer<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttPrepareWriteHeader<S, CompleteState>

where S: Storage,

type Ok = AttPrepareWriteHeader<S, OkState>

fn check_ok( self, ) -> Result<<AttPrepareWriteHeader<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttPrepareWriteHeader<S, OkState>

where S: Storage,

type Ok = AttPrepareWriteHeader<S, OkState>

fn check_ok( self, ) -> Result<<AttPrepareWriteHeader<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttPrepareWriteHeader<S>

where S: Storage,

type Ok = AttPrepareWriteHeader<S, OkState>

fn check_ok(self) -> Result<<AttPrepareWriteHeader<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttPrepareWriteHeaderWriter<S, CompleteState>

where S: MutStorage,

type Ok = AttPrepareWriteHeaderWriter<S, OkState>

fn check_ok( self, ) -> Result<<AttPrepareWriteHeaderWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttPrepareWriteHeaderWriter<S, OkState>

where S: MutStorage,

type Ok = AttPrepareWriteHeaderWriter<S, OkState>

fn check_ok( self, ) -> Result<<AttPrepareWriteHeaderWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttPrepareWriteHeaderWriter<S>

where S: MutStorage,

type Ok = AttPrepareWriteHeaderWriter<S, OkState>

fn check_ok( self, ) -> Result<<AttPrepareWriteHeaderWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttReadBlobReq<S, CompleteState>

where S: Storage,

type Ok = AttReadBlobReq<S, OkState>

fn check_ok( self, ) -> Result<<AttReadBlobReq<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttReadBlobReq<S, OkState>

where S: Storage,

type Ok = AttReadBlobReq<S, OkState>

fn check_ok(self) -> Result<<AttReadBlobReq<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttReadBlobReq<S>

where S: Storage,

type Ok = AttReadBlobReq<S, OkState>

fn check_ok(self) -> Result<<AttReadBlobReq<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttReadBlobReqWriter<S, CompleteState>

where S: MutStorage,

type Ok = AttReadBlobReqWriter<S, OkState>

fn check_ok( self, ) -> Result<<AttReadBlobReqWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttReadBlobReqWriter<S, OkState>

where S: MutStorage,

type Ok = AttReadBlobReqWriter<S, OkState>

fn check_ok( self, ) -> Result<<AttReadBlobReqWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttReadBlobReqWriter<S>

where S: MutStorage,

type Ok = AttReadBlobReqWriter<S, OkState>

fn check_ok(self) -> Result<<AttReadBlobReqWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttReadByGroupTypeReqHeader<S, CompleteState>

where S: Storage,

type Ok = AttReadByGroupTypeReqHeader<S, OkState>

fn check_ok( self, ) -> Result<<AttReadByGroupTypeReqHeader<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttReadByGroupTypeReqHeader<S, OkState>

where S: Storage,

type Ok = AttReadByGroupTypeReqHeader<S, OkState>

fn check_ok( self, ) -> Result<<AttReadByGroupTypeReqHeader<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttReadByGroupTypeReqHeader<S>

where S: Storage,

type Ok = AttReadByGroupTypeReqHeader<S, OkState>

fn check_ok( self, ) -> Result<<AttReadByGroupTypeReqHeader<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttReadByGroupTypeReqHeaderWriter<S, CompleteState>

where S: MutStorage,

type Ok = AttReadByGroupTypeReqHeaderWriter<S, OkState>

fn check_ok( self, ) -> Result<<AttReadByGroupTypeReqHeaderWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttReadByGroupTypeReqHeaderWriter<S, OkState>

where S: MutStorage,

type Ok = AttReadByGroupTypeReqHeaderWriter<S, OkState>

fn check_ok( self, ) -> Result<<AttReadByGroupTypeReqHeaderWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttReadByGroupTypeReqHeaderWriter<S>

where S: MutStorage,

type Ok = AttReadByGroupTypeReqHeaderWriter<S, OkState>

fn check_ok( self, ) -> Result<<AttReadByGroupTypeReqHeaderWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttReadByGroupTypeRspEntryHeader<S, CompleteState>

where S: Storage,

type Ok = AttReadByGroupTypeRspEntryHeader<S, OkState>

fn check_ok( self, ) -> Result<<AttReadByGroupTypeRspEntryHeader<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttReadByGroupTypeRspEntryHeader<S, OkState>

where S: Storage,

type Ok = AttReadByGroupTypeRspEntryHeader<S, OkState>

fn check_ok( self, ) -> Result<<AttReadByGroupTypeRspEntryHeader<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttReadByGroupTypeRspEntryHeader<S>

where S: Storage,

type Ok = AttReadByGroupTypeRspEntryHeader<S, OkState>

fn check_ok( self, ) -> Result<<AttReadByGroupTypeRspEntryHeader<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttReadByGroupTypeRspEntryHeaderWriter<S, CompleteState>

where S: MutStorage,

type Ok = AttReadByGroupTypeRspEntryHeaderWriter<S, OkState>

fn check_ok( self, ) -> Result<<AttReadByGroupTypeRspEntryHeaderWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttReadByGroupTypeRspEntryHeaderWriter<S, OkState>

where S: MutStorage,

type Ok = AttReadByGroupTypeRspEntryHeaderWriter<S, OkState>

fn check_ok( self, ) -> Result<<AttReadByGroupTypeRspEntryHeaderWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttReadByGroupTypeRspEntryHeaderWriter<S>

where S: MutStorage,

type Ok = AttReadByGroupTypeRspEntryHeaderWriter<S, OkState>

fn check_ok( self, ) -> Result<<AttReadByGroupTypeRspEntryHeaderWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttReadByTypeReqHeader<S, CompleteState>

where S: Storage,

type Ok = AttReadByTypeReqHeader<S, OkState>

fn check_ok( self, ) -> Result<<AttReadByTypeReqHeader<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttReadByTypeReqHeader<S, OkState>

where S: Storage,

type Ok = AttReadByTypeReqHeader<S, OkState>

fn check_ok( self, ) -> Result<<AttReadByTypeReqHeader<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttReadByTypeReqHeader<S>

where S: Storage,

type Ok = AttReadByTypeReqHeader<S, OkState>

fn check_ok(self) -> Result<<AttReadByTypeReqHeader<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttReadByTypeReqHeaderWriter<S, CompleteState>

where S: MutStorage,

type Ok = AttReadByTypeReqHeaderWriter<S, OkState>

fn check_ok( self, ) -> Result<<AttReadByTypeReqHeaderWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttReadByTypeReqHeaderWriter<S, OkState>

where S: MutStorage,

type Ok = AttReadByTypeReqHeaderWriter<S, OkState>

fn check_ok( self, ) -> Result<<AttReadByTypeReqHeaderWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttReadByTypeReqHeaderWriter<S>

where S: MutStorage,

type Ok = AttReadByTypeReqHeaderWriter<S, OkState>

fn check_ok( self, ) -> Result<<AttReadByTypeReqHeaderWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttReadReq<S, CompleteState>

where S: Storage,

type Ok = AttReadReq<S, OkState>

fn check_ok( self, ) -> Result<<AttReadReq<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttReadReq<S, OkState>

where S: Storage,

type Ok = AttReadReq<S, OkState>

fn check_ok(self) -> Result<<AttReadReq<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttReadReq<S>

where S: Storage,

type Ok = AttReadReq<S, OkState>

fn check_ok(self) -> Result<<AttReadReq<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttReadReqWriter<S, CompleteState>

where S: MutStorage,

type Ok = AttReadReqWriter<S, OkState>

fn check_ok( self, ) -> Result<<AttReadReqWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttReadReqWriter<S, OkState>

where S: MutStorage,

type Ok = AttReadReqWriter<S, OkState>

fn check_ok( self, ) -> Result<<AttReadReqWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttReadReqWriter<S>

where S: MutStorage,

type Ok = AttReadReqWriter<S, OkState>

fn check_ok(self) -> Result<<AttReadReqWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttWriteCmd<S, CompleteState>

where S: Storage,

type Ok = AttWriteCmd<S, OkState>

fn check_ok( self, ) -> Result<<AttWriteCmd<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttWriteCmd<S, OkState>

where S: Storage,

type Ok = AttWriteCmd<S, OkState>

fn check_ok(self) -> Result<<AttWriteCmd<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttWriteCmd<S>

where S: Storage,

type Ok = AttWriteCmd<S, OkState>

fn check_ok(self) -> Result<<AttWriteCmd<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttWriteCmdWriter<S, CompleteState>

where S: MutStorage,

type Ok = AttWriteCmdWriter<S, OkState>

fn check_ok( self, ) -> Result<<AttWriteCmdWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttWriteCmdWriter<S, OkState>

where S: MutStorage,

type Ok = AttWriteCmdWriter<S, OkState>

fn check_ok( self, ) -> Result<<AttWriteCmdWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AttWriteCmdWriter<S>

where S: MutStorage,

type Ok = AttWriteCmdWriter<S, OkState>

fn check_ok(self) -> Result<<AttWriteCmdWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for AuthenticationRequestedCommand<S, CompleteState>

where S: Storage,

type Ok = AuthenticationRequestedCommand<S, OkState>

fn check_ok( self, ) -> Result<<AuthenticationRequestedCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AuthenticationRequestedCommand<S, OkState>

where S: Storage,

type Ok = AuthenticationRequestedCommand<S, OkState>

fn check_ok( self, ) -> Result<<AuthenticationRequestedCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AuthenticationRequestedCommand<S>

where S: Storage,

type Ok = AuthenticationRequestedCommand<S, OkState>

fn check_ok( self, ) -> Result<<AuthenticationRequestedCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for AuthenticationRequestedCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = AuthenticationRequestedCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<AuthenticationRequestedCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AuthenticationRequestedCommandWriter<S, OkState>

where S: MutStorage,

type Ok = AuthenticationRequestedCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<AuthenticationRequestedCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for AuthenticationRequestedCommandWriter<S>

where S: MutStorage,

type Ok = AuthenticationRequestedCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<AuthenticationRequestedCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for BFrame<S, CompleteState>

where S: Storage,

type Ok = BFrame<S, OkState>

fn check_ok(self) -> Result<<BFrame<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for BFrame<S, OkState>

where S: Storage,

type Ok = BFrame<S, OkState>

fn check_ok(self) -> Result<<BFrame<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for BFrame<S>

where S: Storage,

type Ok = BFrame<S, OkState>

fn check_ok(self) -> Result<<BFrame<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for BFrameHeader<S, CompleteState>

where S: Storage,

type Ok = BFrameHeader<S, OkState>

fn check_ok( self, ) -> Result<<BFrameHeader<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for BFrameHeader<S, OkState>

where S: Storage,

type Ok = BFrameHeader<S, OkState>

fn check_ok(self) -> Result<<BFrameHeader<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for BFrameHeader<S>

where S: Storage,

type Ok = BFrameHeader<S, OkState>

fn check_ok(self) -> Result<<BFrameHeader<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for BFrameHeaderWriter<S, CompleteState>

where S: MutStorage,

type Ok = BFrameHeaderWriter<S, OkState>

fn check_ok( self, ) -> Result<<BFrameHeaderWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for BFrameHeaderWriter<S, OkState>

where S: MutStorage,

type Ok = BFrameHeaderWriter<S, OkState>

fn check_ok( self, ) -> Result<<BFrameHeaderWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for BFrameHeaderWriter<S>

where S: MutStorage,

type Ok = BFrameHeaderWriter<S, OkState>

fn check_ok(self) -> Result<<BFrameHeaderWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for BFrameWriter<S, CompleteState>

where S: MutStorage,

type Ok = BFrameWriter<S, OkState>

fn check_ok( self, ) -> Result<<BFrameWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for BFrameWriter<S, OkState>

where S: MutStorage,

type Ok = BFrameWriter<S, OkState>

fn check_ok(self) -> Result<<BFrameWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for BFrameWriter<S>

where S: MutStorage,

type Ok = BFrameWriter<S, OkState>

fn check_ok(self) -> Result<<BFrameWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for BasicL2capHeader<S, CompleteState>

where S: Storage,

type Ok = BasicL2capHeader<S, OkState>

fn check_ok( self, ) -> Result<<BasicL2capHeader<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for BasicL2capHeader<S, OkState>

where S: Storage,

type Ok = BasicL2capHeader<S, OkState>

fn check_ok( self, ) -> Result<<BasicL2capHeader<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for BasicL2capHeader<S>

where S: Storage,

type Ok = BasicL2capHeader<S, OkState>

fn check_ok(self) -> Result<<BasicL2capHeader<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for BasicL2capHeaderWriter<S, CompleteState>

where S: MutStorage,

type Ok = BasicL2capHeaderWriter<S, OkState>

fn check_ok( self, ) -> Result<<BasicL2capHeaderWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for BasicL2capHeaderWriter<S, OkState>

where S: MutStorage,

type Ok = BasicL2capHeaderWriter<S, OkState>

fn check_ok( self, ) -> Result<<BasicL2capHeaderWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for BasicL2capHeaderWriter<S>

where S: MutStorage,

type Ok = BasicL2capHeaderWriter<S, OkState>

fn check_ok(self) -> Result<<BasicL2capHeaderWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for BdAddr<S, CompleteState>

where S: Storage,

type Ok = BdAddr<S, OkState>

fn check_ok(self) -> Result<<BdAddr<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for BdAddr<S, OkState>

where S: Storage,

type Ok = BdAddr<S, OkState>

fn check_ok(self) -> Result<<BdAddr<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for BdAddr<S>

where S: Storage,

type Ok = BdAddr<S, OkState>

fn check_ok(self) -> Result<<BdAddr<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for BdAddrWriter<S, CompleteState>

where S: MutStorage,

type Ok = BdAddrWriter<S, OkState>

fn check_ok( self, ) -> Result<<BdAddrWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for BdAddrWriter<S, OkState>

where S: MutStorage,

type Ok = BdAddrWriter<S, OkState>

fn check_ok(self) -> Result<<BdAddrWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for BdAddrWriter<S>

where S: MutStorage,

type Ok = BdAddrWriter<S, OkState>

fn check_ok(self) -> Result<<BdAddrWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for CFrame<S, CompleteState>

where S: Storage,

type Ok = CFrame<S, OkState>

fn check_ok(self) -> Result<<CFrame<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for CFrame<S, OkState>

where S: Storage,

type Ok = CFrame<S, OkState>

fn check_ok(self) -> Result<<CFrame<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for CFrame<S>

where S: Storage,

type Ok = CFrame<S, OkState>

fn check_ok(self) -> Result<<CFrame<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for CFrameWriter<S, CompleteState>

where S: MutStorage,

type Ok = CFrameWriter<S, OkState>

fn check_ok( self, ) -> Result<<CFrameWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for CFrameWriter<S, OkState>

where S: MutStorage,

type Ok = CFrameWriter<S, OkState>

fn check_ok(self) -> Result<<CFrameWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for CFrameWriter<S>

where S: MutStorage,

type Ok = CFrameWriter<S, OkState>

fn check_ok(self) -> Result<<CFrameWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ChangeConnectionPacketTypeCommand<S, CompleteState>

where S: Storage,

type Ok = ChangeConnectionPacketTypeCommand<S, OkState>

fn check_ok( self, ) -> Result<<ChangeConnectionPacketTypeCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ChangeConnectionPacketTypeCommand<S, OkState>

where S: Storage,

type Ok = ChangeConnectionPacketTypeCommand<S, OkState>

fn check_ok( self, ) -> Result<<ChangeConnectionPacketTypeCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ChangeConnectionPacketTypeCommand<S>

where S: Storage,

type Ok = ChangeConnectionPacketTypeCommand<S, OkState>

fn check_ok( self, ) -> Result<<ChangeConnectionPacketTypeCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ChangeConnectionPacketTypeCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = ChangeConnectionPacketTypeCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ChangeConnectionPacketTypeCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ChangeConnectionPacketTypeCommandWriter<S, OkState>

where S: MutStorage,

type Ok = ChangeConnectionPacketTypeCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ChangeConnectionPacketTypeCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ChangeConnectionPacketTypeCommandWriter<S>

where S: MutStorage,

type Ok = ChangeConnectionPacketTypeCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ChangeConnectionPacketTypeCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ClassOfDevice<S, CompleteState>

where S: Storage,

type Ok = ClassOfDevice<S, OkState>

fn check_ok( self, ) -> Result<<ClassOfDevice<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ClassOfDevice<S, OkState>

where S: Storage,

type Ok = ClassOfDevice<S, OkState>

fn check_ok(self) -> Result<<ClassOfDevice<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ClassOfDevice<S>

where S: Storage,

type Ok = ClassOfDevice<S, OkState>

fn check_ok(self) -> Result<<ClassOfDevice<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ClassOfDeviceWriter<S, CompleteState>

where S: MutStorage,

type Ok = ClassOfDeviceWriter<S, OkState>

fn check_ok( self, ) -> Result<<ClassOfDeviceWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ClassOfDeviceWriter<S, OkState>

where S: MutStorage,

type Ok = ClassOfDeviceWriter<S, OkState>

fn check_ok( self, ) -> Result<<ClassOfDeviceWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ClassOfDeviceWriter<S>

where S: MutStorage,

type Ok = ClassOfDeviceWriter<S, OkState>

fn check_ok(self) -> Result<<ClassOfDeviceWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ClockOffset<S, CompleteState>

where S: Storage,

type Ok = ClockOffset<S, OkState>

fn check_ok( self, ) -> Result<<ClockOffset<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ClockOffset<S, OkState>

where S: Storage,

type Ok = ClockOffset<S, OkState>

fn check_ok(self) -> Result<<ClockOffset<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ClockOffset<S>

where S: Storage,

type Ok = ClockOffset<S, OkState>

fn check_ok(self) -> Result<<ClockOffset<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ClockOffsetWriter<S, CompleteState>

where S: MutStorage,

type Ok = ClockOffsetWriter<S, OkState>

fn check_ok( self, ) -> Result<<ClockOffsetWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ClockOffsetWriter<S, OkState>

where S: MutStorage,

type Ok = ClockOffsetWriter<S, OkState>

fn check_ok( self, ) -> Result<<ClockOffsetWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ClockOffsetWriter<S>

where S: MutStorage,

type Ok = ClockOffsetWriter<S, OkState>

fn check_ok(self) -> Result<<ClockOffsetWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for CodecId<S, CompleteState>

where S: Storage,

type Ok = CodecId<S, OkState>

fn check_ok(self) -> Result<<CodecId<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for CodecId<S, OkState>

where S: Storage,

type Ok = CodecId<S, OkState>

fn check_ok(self) -> Result<<CodecId<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for CodecId<S>

where S: Storage,

type Ok = CodecId<S, OkState>

fn check_ok(self) -> Result<<CodecId<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for CodecIdWriter<S, CompleteState>

where S: MutStorage,

type Ok = CodecIdWriter<S, OkState>

fn check_ok( self, ) -> Result<<CodecIdWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for CodecIdWriter<S, OkState>

where S: MutStorage,

type Ok = CodecIdWriter<S, OkState>

fn check_ok(self) -> Result<<CodecIdWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for CodecIdWriter<S>

where S: MutStorage,

type Ok = CodecIdWriter<S, OkState>

fn check_ok(self) -> Result<<CodecIdWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for CommandCompleteEvent<S, CompleteState>

where S: Storage,

type Ok = CommandCompleteEvent<S, OkState>

fn check_ok( self, ) -> Result<<CommandCompleteEvent<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for CommandCompleteEvent<S, OkState>

where S: Storage,

type Ok = CommandCompleteEvent<S, OkState>

fn check_ok( self, ) -> Result<<CommandCompleteEvent<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for CommandCompleteEvent<S>

where S: Storage,

type Ok = CommandCompleteEvent<S, OkState>

fn check_ok(self) -> Result<<CommandCompleteEvent<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for CommandCompleteEventWriter<S, CompleteState>

where S: MutStorage,

type Ok = CommandCompleteEventWriter<S, OkState>

fn check_ok( self, ) -> Result<<CommandCompleteEventWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for CommandCompleteEventWriter<S, OkState>

where S: MutStorage,

type Ok = CommandCompleteEventWriter<S, OkState>

fn check_ok( self, ) -> Result<<CommandCompleteEventWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for CommandCompleteEventWriter<S>

where S: MutStorage,

type Ok = CommandCompleteEventWriter<S, OkState>

fn check_ok( self, ) -> Result<<CommandCompleteEventWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for CommandHeader<S, CompleteState>

where S: Storage,

type Ok = CommandHeader<S, OkState>

fn check_ok( self, ) -> Result<<CommandHeader<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for CommandHeader<S, OkState>

where S: Storage,

type Ok = CommandHeader<S, OkState>

fn check_ok(self) -> Result<<CommandHeader<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for CommandHeader<S>

where S: Storage,

type Ok = CommandHeader<S, OkState>

fn check_ok(self) -> Result<<CommandHeader<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for CommandHeaderWriter<S, CompleteState>

where S: MutStorage,

type Ok = CommandHeaderWriter<S, OkState>

fn check_ok( self, ) -> Result<<CommandHeaderWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for CommandHeaderWriter<S, OkState>

where S: MutStorage,

type Ok = CommandHeaderWriter<S, OkState>

fn check_ok( self, ) -> Result<<CommandHeaderWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for CommandHeaderWriter<S>

where S: MutStorage,

type Ok = CommandHeaderWriter<S, OkState>

fn check_ok(self) -> Result<<CommandHeaderWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for CommandPacket<S, CompleteState>

where S: Storage,

type Ok = CommandPacket<S, OkState>

fn check_ok( self, ) -> Result<<CommandPacket<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for CommandPacket<S, OkState>

where S: Storage,

type Ok = CommandPacket<S, OkState>

fn check_ok(self) -> Result<<CommandPacket<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for CommandPacket<S>

where S: Storage,

type Ok = CommandPacket<S, OkState>

fn check_ok(self) -> Result<<CommandPacket<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for CommandPacketWriter<S, CompleteState>

where S: MutStorage,

type Ok = CommandPacketWriter<S, OkState>

fn check_ok( self, ) -> Result<<CommandPacketWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for CommandPacketWriter<S, OkState>

where S: MutStorage,

type Ok = CommandPacketWriter<S, OkState>

fn check_ok( self, ) -> Result<<CommandPacketWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for CommandPacketWriter<S>

where S: MutStorage,

type Ok = CommandPacketWriter<S, OkState>

fn check_ok(self) -> Result<<CommandPacketWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for CreateConnectionCancelCommand<S, CompleteState>

where S: Storage,

type Ok = CreateConnectionCancelCommand<S, OkState>

fn check_ok( self, ) -> Result<<CreateConnectionCancelCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for CreateConnectionCancelCommand<S, OkState>

where S: Storage,

type Ok = CreateConnectionCancelCommand<S, OkState>

fn check_ok( self, ) -> Result<<CreateConnectionCancelCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for CreateConnectionCancelCommand<S>

where S: Storage,

type Ok = CreateConnectionCancelCommand<S, OkState>

fn check_ok( self, ) -> Result<<CreateConnectionCancelCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for CreateConnectionCancelCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = CreateConnectionCancelCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<CreateConnectionCancelCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for CreateConnectionCancelCommandWriter<S, OkState>

where S: MutStorage,

type Ok = CreateConnectionCancelCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<CreateConnectionCancelCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for CreateConnectionCancelCommandWriter<S>

where S: MutStorage,

type Ok = CreateConnectionCancelCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<CreateConnectionCancelCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for CreateConnectionCommand<S, CompleteState>

where S: Storage,

type Ok = CreateConnectionCommand<S, OkState>

fn check_ok( self, ) -> Result<<CreateConnectionCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for CreateConnectionCommand<S, OkState>

where S: Storage,

type Ok = CreateConnectionCommand<S, OkState>

fn check_ok( self, ) -> Result<<CreateConnectionCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for CreateConnectionCommand<S>

where S: Storage,

type Ok = CreateConnectionCommand<S, OkState>

fn check_ok(self) -> Result<<CreateConnectionCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for CreateConnectionCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = CreateConnectionCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<CreateConnectionCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for CreateConnectionCommandWriter<S, OkState>

where S: MutStorage,

type Ok = CreateConnectionCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<CreateConnectionCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for CreateConnectionCommandWriter<S>

where S: MutStorage,

type Ok = CreateConnectionCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<CreateConnectionCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for DisconnectCommand<S, CompleteState>

where S: Storage,

type Ok = DisconnectCommand<S, OkState>

fn check_ok( self, ) -> Result<<DisconnectCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for DisconnectCommand<S, OkState>

where S: Storage,

type Ok = DisconnectCommand<S, OkState>

fn check_ok( self, ) -> Result<<DisconnectCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for DisconnectCommand<S>

where S: Storage,

type Ok = DisconnectCommand<S, OkState>

fn check_ok(self) -> Result<<DisconnectCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for DisconnectCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = DisconnectCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<DisconnectCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for DisconnectCommandWriter<S, OkState>

where S: MutStorage,

type Ok = DisconnectCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<DisconnectCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for DisconnectCommandWriter<S>

where S: MutStorage,

type Ok = DisconnectCommandWriter<S, OkState>

fn check_ok(self) -> Result<<DisconnectCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for EnhancedAcceptSynchronousConnectionRequestCommand<S, CompleteState>

where S: Storage,

type Ok = EnhancedAcceptSynchronousConnectionRequestCommand<S, OkState>

fn check_ok( self, ) -> Result<<EnhancedAcceptSynchronousConnectionRequestCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for EnhancedAcceptSynchronousConnectionRequestCommand<S, OkState>

where S: Storage,

type Ok = EnhancedAcceptSynchronousConnectionRequestCommand<S, OkState>

fn check_ok( self, ) -> Result<<EnhancedAcceptSynchronousConnectionRequestCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for EnhancedAcceptSynchronousConnectionRequestCommand<S>

where S: Storage,

type Ok = EnhancedAcceptSynchronousConnectionRequestCommand<S, OkState>

fn check_ok( self, ) -> Result<<EnhancedAcceptSynchronousConnectionRequestCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for EnhancedAcceptSynchronousConnectionRequestCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = EnhancedAcceptSynchronousConnectionRequestCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<EnhancedAcceptSynchronousConnectionRequestCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for EnhancedAcceptSynchronousConnectionRequestCommandWriter<S, OkState>

where S: MutStorage,

type Ok = EnhancedAcceptSynchronousConnectionRequestCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<EnhancedAcceptSynchronousConnectionRequestCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for EnhancedAcceptSynchronousConnectionRequestCommandWriter<S>

where S: MutStorage,

type Ok = EnhancedAcceptSynchronousConnectionRequestCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<EnhancedAcceptSynchronousConnectionRequestCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for EnhancedSetupSynchronousConnectionCommand<S, CompleteState>

where S: Storage,

type Ok = EnhancedSetupSynchronousConnectionCommand<S, OkState>

fn check_ok( self, ) -> Result<<EnhancedSetupSynchronousConnectionCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for EnhancedSetupSynchronousConnectionCommand<S, OkState>

where S: Storage,

type Ok = EnhancedSetupSynchronousConnectionCommand<S, OkState>

fn check_ok( self, ) -> Result<<EnhancedSetupSynchronousConnectionCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for EnhancedSetupSynchronousConnectionCommand<S>

where S: Storage,

type Ok = EnhancedSetupSynchronousConnectionCommand<S, OkState>

fn check_ok( self, ) -> Result<<EnhancedSetupSynchronousConnectionCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for EnhancedSetupSynchronousConnectionCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = EnhancedSetupSynchronousConnectionCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<EnhancedSetupSynchronousConnectionCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for EnhancedSetupSynchronousConnectionCommandWriter<S, OkState>

where S: MutStorage,

type Ok = EnhancedSetupSynchronousConnectionCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<EnhancedSetupSynchronousConnectionCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for EnhancedSetupSynchronousConnectionCommandWriter<S>

where S: MutStorage,

type Ok = EnhancedSetupSynchronousConnectionCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<EnhancedSetupSynchronousConnectionCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for EventHeader<S, CompleteState>

where S: Storage,

type Ok = EventHeader<S, OkState>

fn check_ok( self, ) -> Result<<EventHeader<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for EventHeader<S, OkState>

where S: Storage,

type Ok = EventHeader<S, OkState>

fn check_ok(self) -> Result<<EventHeader<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for EventHeader<S>

where S: Storage,

type Ok = EventHeader<S, OkState>

fn check_ok(self) -> Result<<EventHeader<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for EventHeaderWriter<S, CompleteState>

where S: MutStorage,

type Ok = EventHeaderWriter<S, OkState>

fn check_ok( self, ) -> Result<<EventHeaderWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for EventHeaderWriter<S, OkState>

where S: MutStorage,

type Ok = EventHeaderWriter<S, OkState>

fn check_ok( self, ) -> Result<<EventHeaderWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for EventHeaderWriter<S>

where S: MutStorage,

type Ok = EventHeaderWriter<S, OkState>

fn check_ok(self) -> Result<<EventHeaderWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for EventMask<S, CompleteState>

where S: Storage,

type Ok = EventMask<S, OkState>

fn check_ok(self) -> Result<<EventMask<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for EventMask<S, OkState>

where S: Storage,

type Ok = EventMask<S, OkState>

fn check_ok(self) -> Result<<EventMask<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for EventMask<S>

where S: Storage,

type Ok = EventMask<S, OkState>

fn check_ok(self) -> Result<<EventMask<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for EventMaskPage2<S, CompleteState>

where S: Storage,

type Ok = EventMaskPage2<S, OkState>

fn check_ok( self, ) -> Result<<EventMaskPage2<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for EventMaskPage2<S, OkState>

where S: Storage,

type Ok = EventMaskPage2<S, OkState>

fn check_ok(self) -> Result<<EventMaskPage2<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for EventMaskPage2<S>

where S: Storage,

type Ok = EventMaskPage2<S, OkState>

fn check_ok(self) -> Result<<EventMaskPage2<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for EventMaskPage2Writer<S, CompleteState>

where S: MutStorage,

type Ok = EventMaskPage2Writer<S, OkState>

fn check_ok( self, ) -> Result<<EventMaskPage2Writer<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for EventMaskPage2Writer<S, OkState>

where S: MutStorage,

type Ok = EventMaskPage2Writer<S, OkState>

fn check_ok( self, ) -> Result<<EventMaskPage2Writer<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for EventMaskPage2Writer<S>

where S: MutStorage,

type Ok = EventMaskPage2Writer<S, OkState>

fn check_ok(self) -> Result<<EventMaskPage2Writer<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for EventMaskWriter<S, CompleteState>

where S: MutStorage,

type Ok = EventMaskWriter<S, OkState>

fn check_ok( self, ) -> Result<<EventMaskWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for EventMaskWriter<S, OkState>

where S: MutStorage,

type Ok = EventMaskWriter<S, OkState>

fn check_ok(self) -> Result<<EventMaskWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for EventMaskWriter<S>

where S: MutStorage,

type Ok = EventMaskWriter<S, OkState>

fn check_ok(self) -> Result<<EventMaskWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for EventPacket<S, CompleteState>

where S: Storage,

type Ok = EventPacket<S, OkState>

fn check_ok( self, ) -> Result<<EventPacket<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for EventPacket<S, OkState>

where S: Storage,

type Ok = EventPacket<S, OkState>

fn check_ok(self) -> Result<<EventPacket<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for EventPacket<S>

where S: Storage,

type Ok = EventPacket<S, OkState>

fn check_ok(self) -> Result<<EventPacket<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for EventPacketWriter<S, CompleteState>

where S: MutStorage,

type Ok = EventPacketWriter<S, OkState>

fn check_ok( self, ) -> Result<<EventPacketWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for EventPacketWriter<S, OkState>

where S: MutStorage,

type Ok = EventPacketWriter<S, OkState>

fn check_ok( self, ) -> Result<<EventPacketWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for EventPacketWriter<S>

where S: MutStorage,

type Ok = EventPacketWriter<S, OkState>

fn check_ok(self) -> Result<<EventPacketWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ExitSniffModeCommand<S, CompleteState>

where S: Storage,

type Ok = ExitSniffModeCommand<S, OkState>

fn check_ok( self, ) -> Result<<ExitSniffModeCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ExitSniffModeCommand<S, OkState>

where S: Storage,

type Ok = ExitSniffModeCommand<S, OkState>

fn check_ok( self, ) -> Result<<ExitSniffModeCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ExitSniffModeCommand<S>

where S: Storage,

type Ok = ExitSniffModeCommand<S, OkState>

fn check_ok(self) -> Result<<ExitSniffModeCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ExitSniffModeCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = ExitSniffModeCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ExitSniffModeCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ExitSniffModeCommandWriter<S, OkState>

where S: MutStorage,

type Ok = ExitSniffModeCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ExitSniffModeCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ExitSniffModeCommandWriter<S>

where S: MutStorage,

type Ok = ExitSniffModeCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ExitSniffModeCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ExtendedInquiryResponse<S, CompleteState>

where S: Storage,

type Ok = ExtendedInquiryResponse<S, OkState>

fn check_ok( self, ) -> Result<<ExtendedInquiryResponse<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ExtendedInquiryResponse<S, OkState>

where S: Storage,

type Ok = ExtendedInquiryResponse<S, OkState>

fn check_ok( self, ) -> Result<<ExtendedInquiryResponse<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ExtendedInquiryResponse<S>

where S: Storage,

type Ok = ExtendedInquiryResponse<S, OkState>

fn check_ok(self) -> Result<<ExtendedInquiryResponse<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ExtendedInquiryResponseWriter<S, CompleteState>

where S: MutStorage,

type Ok = ExtendedInquiryResponseWriter<S, OkState>

fn check_ok( self, ) -> Result<<ExtendedInquiryResponseWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ExtendedInquiryResponseWriter<S, OkState>

where S: MutStorage,

type Ok = ExtendedInquiryResponseWriter<S, OkState>

fn check_ok( self, ) -> Result<<ExtendedInquiryResponseWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ExtendedInquiryResponseWriter<S>

where S: MutStorage,

type Ok = ExtendedInquiryResponseWriter<S, OkState>

fn check_ok( self, ) -> Result<<ExtendedInquiryResponseWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for FirstKFrame<S, CompleteState>

where S: Storage,

type Ok = FirstKFrame<S, OkState>

fn check_ok( self, ) -> Result<<FirstKFrame<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for FirstKFrame<S, OkState>

where S: Storage,

type Ok = FirstKFrame<S, OkState>

fn check_ok(self) -> Result<<FirstKFrame<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for FirstKFrame<S>

where S: Storage,

type Ok = FirstKFrame<S, OkState>

fn check_ok(self) -> Result<<FirstKFrame<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for FirstKFrameWriter<S, CompleteState>

where S: MutStorage,

type Ok = FirstKFrameWriter<S, OkState>

fn check_ok( self, ) -> Result<<FirstKFrameWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for FirstKFrameWriter<S, OkState>

where S: MutStorage,

type Ok = FirstKFrameWriter<S, OkState>

fn check_ok( self, ) -> Result<<FirstKFrameWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for FirstKFrameWriter<S>

where S: MutStorage,

type Ok = FirstKFrameWriter<S, OkState>

fn check_ok(self) -> Result<<FirstKFrameWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for GenericHciCommand<S, CompleteState>

where S: Storage,

type Ok = GenericHciCommand<S, OkState>

fn check_ok( self, ) -> Result<<GenericHciCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for GenericHciCommand<S, OkState>

where S: Storage,

type Ok = GenericHciCommand<S, OkState>

fn check_ok( self, ) -> Result<<GenericHciCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for GenericHciCommand<S>

where S: Storage,

type Ok = GenericHciCommand<S, OkState>

fn check_ok(self) -> Result<<GenericHciCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for GenericHciCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = GenericHciCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<GenericHciCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for GenericHciCommandWriter<S, OkState>

where S: MutStorage,

type Ok = GenericHciCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<GenericHciCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for GenericHciCommandWriter<S>

where S: MutStorage,

type Ok = GenericHciCommandWriter<S, OkState>

fn check_ok(self) -> Result<<GenericHciCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for HostBufferSizeCommand<S, CompleteState>

where S: Storage,

type Ok = HostBufferSizeCommand<S, OkState>

fn check_ok( self, ) -> Result<<HostBufferSizeCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for HostBufferSizeCommand<S, OkState>

where S: Storage,

type Ok = HostBufferSizeCommand<S, OkState>

fn check_ok( self, ) -> Result<<HostBufferSizeCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for HostBufferSizeCommand<S>

where S: Storage,

type Ok = HostBufferSizeCommand<S, OkState>

fn check_ok(self) -> Result<<HostBufferSizeCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for HostBufferSizeCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = HostBufferSizeCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<HostBufferSizeCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for HostBufferSizeCommandWriter<S, OkState>

where S: MutStorage,

type Ok = HostBufferSizeCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<HostBufferSizeCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for HostBufferSizeCommandWriter<S>

where S: MutStorage,

type Ok = HostBufferSizeCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<HostBufferSizeCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ImagingMinorDeviceClassBits<S, CompleteState>

where S: Storage,

type Ok = ImagingMinorDeviceClassBits<S, OkState>

fn check_ok( self, ) -> Result<<ImagingMinorDeviceClassBits<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ImagingMinorDeviceClassBits<S, OkState>

where S: Storage,

type Ok = ImagingMinorDeviceClassBits<S, OkState>

fn check_ok( self, ) -> Result<<ImagingMinorDeviceClassBits<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ImagingMinorDeviceClassBits<S>

where S: Storage,

type Ok = ImagingMinorDeviceClassBits<S, OkState>

fn check_ok( self, ) -> Result<<ImagingMinorDeviceClassBits<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ImagingMinorDeviceClassBitsWriter<S, CompleteState>

where S: MutStorage,

type Ok = ImagingMinorDeviceClassBitsWriter<S, OkState>

fn check_ok( self, ) -> Result<<ImagingMinorDeviceClassBitsWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ImagingMinorDeviceClassBitsWriter<S, OkState>

where S: MutStorage,

type Ok = ImagingMinorDeviceClassBitsWriter<S, OkState>

fn check_ok( self, ) -> Result<<ImagingMinorDeviceClassBitsWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ImagingMinorDeviceClassBitsWriter<S>

where S: MutStorage,

type Ok = ImagingMinorDeviceClassBitsWriter<S, OkState>

fn check_ok( self, ) -> Result<<ImagingMinorDeviceClassBitsWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for InquiryCancelCommand<S, CompleteState>

where S: Storage,

type Ok = InquiryCancelCommand<S, OkState>

fn check_ok( self, ) -> Result<<InquiryCancelCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for InquiryCancelCommand<S, OkState>

where S: Storage,

type Ok = InquiryCancelCommand<S, OkState>

fn check_ok( self, ) -> Result<<InquiryCancelCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for InquiryCancelCommand<S>

where S: Storage,

type Ok = InquiryCancelCommand<S, OkState>

fn check_ok(self) -> Result<<InquiryCancelCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for InquiryCancelCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = InquiryCancelCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<InquiryCancelCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for InquiryCancelCommandWriter<S, OkState>

where S: MutStorage,

type Ok = InquiryCancelCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<InquiryCancelCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for InquiryCancelCommandWriter<S>

where S: MutStorage,

type Ok = InquiryCancelCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<InquiryCancelCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for InquiryCommand<S, CompleteState>

where S: Storage,

type Ok = InquiryCommand<S, OkState>

fn check_ok( self, ) -> Result<<InquiryCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for InquiryCommand<S, OkState>

where S: Storage,

type Ok = InquiryCommand<S, OkState>

fn check_ok(self) -> Result<<InquiryCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for InquiryCommand<S>

where S: Storage,

type Ok = InquiryCommand<S, OkState>

fn check_ok(self) -> Result<<InquiryCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for InquiryCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = InquiryCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<InquiryCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for InquiryCommandWriter<S, OkState>

where S: MutStorage,

type Ok = InquiryCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<InquiryCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for InquiryCommandWriter<S>

where S: MutStorage,

type Ok = InquiryCommandWriter<S, OkState>

fn check_ok(self) -> Result<<InquiryCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for IoCapabilityRequestNegativeReplyCommand<S, CompleteState>

where S: Storage,

type Ok = IoCapabilityRequestNegativeReplyCommand<S, OkState>

fn check_ok( self, ) -> Result<<IoCapabilityRequestNegativeReplyCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for IoCapabilityRequestNegativeReplyCommand<S, OkState>

where S: Storage,

type Ok = IoCapabilityRequestNegativeReplyCommand<S, OkState>

fn check_ok( self, ) -> Result<<IoCapabilityRequestNegativeReplyCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for IoCapabilityRequestNegativeReplyCommand<S>

where S: Storage,

type Ok = IoCapabilityRequestNegativeReplyCommand<S, OkState>

fn check_ok( self, ) -> Result<<IoCapabilityRequestNegativeReplyCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for IoCapabilityRequestNegativeReplyCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = IoCapabilityRequestNegativeReplyCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<IoCapabilityRequestNegativeReplyCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for IoCapabilityRequestNegativeReplyCommandWriter<S, OkState>

where S: MutStorage,

type Ok = IoCapabilityRequestNegativeReplyCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<IoCapabilityRequestNegativeReplyCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for IoCapabilityRequestNegativeReplyCommandWriter<S>

where S: MutStorage,

type Ok = IoCapabilityRequestNegativeReplyCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<IoCapabilityRequestNegativeReplyCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for IoCapabilityRequestReplyCommand<S, CompleteState>

where S: Storage,

type Ok = IoCapabilityRequestReplyCommand<S, OkState>

fn check_ok( self, ) -> Result<<IoCapabilityRequestReplyCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for IoCapabilityRequestReplyCommand<S, OkState>

where S: Storage,

type Ok = IoCapabilityRequestReplyCommand<S, OkState>

fn check_ok( self, ) -> Result<<IoCapabilityRequestReplyCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for IoCapabilityRequestReplyCommand<S>

where S: Storage,

type Ok = IoCapabilityRequestReplyCommand<S, OkState>

fn check_ok( self, ) -> Result<<IoCapabilityRequestReplyCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for IoCapabilityRequestReplyCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = IoCapabilityRequestReplyCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<IoCapabilityRequestReplyCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for IoCapabilityRequestReplyCommandWriter<S, OkState>

where S: MutStorage,

type Ok = IoCapabilityRequestReplyCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<IoCapabilityRequestReplyCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for IoCapabilityRequestReplyCommandWriter<S>

where S: MutStorage,

type Ok = IoCapabilityRequestReplyCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<IoCapabilityRequestReplyCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for IsoDataFrameHeader<S, CompleteState>

where S: Storage,

type Ok = IsoDataFrameHeader<S, OkState>

fn check_ok( self, ) -> Result<<IsoDataFrameHeader<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for IsoDataFrameHeader<S, OkState>

where S: Storage,

type Ok = IsoDataFrameHeader<S, OkState>

fn check_ok( self, ) -> Result<<IsoDataFrameHeader<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for IsoDataFrameHeader<S>

where S: Storage,

type Ok = IsoDataFrameHeader<S, OkState>

fn check_ok(self) -> Result<<IsoDataFrameHeader<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for IsoDataFrameHeaderWriter<S, CompleteState>

where S: MutStorage,

type Ok = IsoDataFrameHeaderWriter<S, OkState>

fn check_ok( self, ) -> Result<<IsoDataFrameHeaderWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for IsoDataFrameHeaderWriter<S, OkState>

where S: MutStorage,

type Ok = IsoDataFrameHeaderWriter<S, OkState>

fn check_ok( self, ) -> Result<<IsoDataFrameHeaderWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for IsoDataFrameHeaderWriter<S>

where S: MutStorage,

type Ok = IsoDataFrameHeaderWriter<S, OkState>

fn check_ok(self) -> Result<<IsoDataFrameHeaderWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for IsoDataFrameHeader_EmbossReservedAnonymousField3<S, CompleteState>

where S: Storage,

type Ok = IsoDataFrameHeader_EmbossReservedAnonymousField3<S, OkState>

fn check_ok( self, ) -> Result<<IsoDataFrameHeader_EmbossReservedAnonymousField3<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for IsoDataFrameHeader_EmbossReservedAnonymousField3<S, OkState>

where S: Storage,

type Ok = IsoDataFrameHeader_EmbossReservedAnonymousField3<S, OkState>

fn check_ok( self, ) -> Result<<IsoDataFrameHeader_EmbossReservedAnonymousField3<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for IsoDataFrameHeader_EmbossReservedAnonymousField3<S>

where S: Storage,

type Ok = IsoDataFrameHeader_EmbossReservedAnonymousField3<S, OkState>

fn check_ok( self, ) -> Result<<IsoDataFrameHeader_EmbossReservedAnonymousField3<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for IsoDataFrameHeader_EmbossReservedAnonymousField3Writer<S, CompleteState>

where S: MutStorage,

type Ok = IsoDataFrameHeader_EmbossReservedAnonymousField3Writer<S, OkState>

fn check_ok( self, ) -> Result<<IsoDataFrameHeader_EmbossReservedAnonymousField3Writer<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for IsoDataFrameHeader_EmbossReservedAnonymousField3Writer<S, OkState>

where S: MutStorage,

type Ok = IsoDataFrameHeader_EmbossReservedAnonymousField3Writer<S, OkState>

fn check_ok( self, ) -> Result<<IsoDataFrameHeader_EmbossReservedAnonymousField3Writer<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for IsoDataFrameHeader_EmbossReservedAnonymousField3Writer<S>

where S: MutStorage,

type Ok = IsoDataFrameHeader_EmbossReservedAnonymousField3Writer<S, OkState>

fn check_ok( self, ) -> Result<<IsoDataFrameHeader_EmbossReservedAnonymousField3Writer<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for IsoDataFramePacket<S, CompleteState>

where S: Storage,

type Ok = IsoDataFramePacket<S, OkState>

fn check_ok( self, ) -> Result<<IsoDataFramePacket<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for IsoDataFramePacket<S, OkState>

where S: Storage,

type Ok = IsoDataFramePacket<S, OkState>

fn check_ok( self, ) -> Result<<IsoDataFramePacket<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for IsoDataFramePacket<S>

where S: Storage,

type Ok = IsoDataFramePacket<S, OkState>

fn check_ok(self) -> Result<<IsoDataFramePacket<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for IsoDataFramePacketWriter<S, CompleteState>

where S: MutStorage,

type Ok = IsoDataFramePacketWriter<S, OkState>

fn check_ok( self, ) -> Result<<IsoDataFramePacketWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for IsoDataFramePacketWriter<S, OkState>

where S: MutStorage,

type Ok = IsoDataFramePacketWriter<S, OkState>

fn check_ok( self, ) -> Result<<IsoDataFramePacketWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for IsoDataFramePacketWriter<S>

where S: MutStorage,

type Ok = IsoDataFramePacketWriter<S, OkState>

fn check_ok(self) -> Result<<IsoDataFramePacketWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for IsoDataFramePacket_EmbossReservedAnonymousField2<S, CompleteState>

where S: Storage,

type Ok = IsoDataFramePacket_EmbossReservedAnonymousField2<S, OkState>

fn check_ok( self, ) -> Result<<IsoDataFramePacket_EmbossReservedAnonymousField2<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for IsoDataFramePacket_EmbossReservedAnonymousField2<S, OkState>

where S: Storage,

type Ok = IsoDataFramePacket_EmbossReservedAnonymousField2<S, OkState>

fn check_ok( self, ) -> Result<<IsoDataFramePacket_EmbossReservedAnonymousField2<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for IsoDataFramePacket_EmbossReservedAnonymousField2<S>

where S: Storage,

type Ok = IsoDataFramePacket_EmbossReservedAnonymousField2<S, OkState>

fn check_ok( self, ) -> Result<<IsoDataFramePacket_EmbossReservedAnonymousField2<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for IsoDataFramePacket_EmbossReservedAnonymousField2Writer<S, CompleteState>

where S: MutStorage,

type Ok = IsoDataFramePacket_EmbossReservedAnonymousField2Writer<S, OkState>

fn check_ok( self, ) -> Result<<IsoDataFramePacket_EmbossReservedAnonymousField2Writer<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for IsoDataFramePacket_EmbossReservedAnonymousField2Writer<S, OkState>

where S: MutStorage,

type Ok = IsoDataFramePacket_EmbossReservedAnonymousField2Writer<S, OkState>

fn check_ok( self, ) -> Result<<IsoDataFramePacket_EmbossReservedAnonymousField2Writer<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for IsoDataFramePacket_EmbossReservedAnonymousField2Writer<S>

where S: MutStorage,

type Ok = IsoDataFramePacket_EmbossReservedAnonymousField2Writer<S, OkState>

fn check_ok( self, ) -> Result<<IsoDataFramePacket_EmbossReservedAnonymousField2Writer<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for KFramePduHeader<S, CompleteState>

where S: Storage,

type Ok = KFramePduHeader<S, OkState>

fn check_ok( self, ) -> Result<<KFramePduHeader<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for KFramePduHeader<S, OkState>

where S: Storage,

type Ok = KFramePduHeader<S, OkState>

fn check_ok(self) -> Result<<KFramePduHeader<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for KFramePduHeader<S>

where S: Storage,

type Ok = KFramePduHeader<S, OkState>

fn check_ok(self) -> Result<<KFramePduHeader<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for KFramePduHeaderWriter<S, CompleteState>

where S: MutStorage,

type Ok = KFramePduHeaderWriter<S, OkState>

fn check_ok( self, ) -> Result<<KFramePduHeaderWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for KFramePduHeaderWriter<S, OkState>

where S: MutStorage,

type Ok = KFramePduHeaderWriter<S, OkState>

fn check_ok( self, ) -> Result<<KFramePduHeaderWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for KFramePduHeaderWriter<S>

where S: MutStorage,

type Ok = KFramePduHeaderWriter<S, OkState>

fn check_ok(self) -> Result<<KFramePduHeaderWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for KFrameSduHeader<S, CompleteState>

where S: Storage,

type Ok = KFrameSduHeader<S, OkState>

fn check_ok( self, ) -> Result<<KFrameSduHeader<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for KFrameSduHeader<S, OkState>

where S: Storage,

type Ok = KFrameSduHeader<S, OkState>

fn check_ok(self) -> Result<<KFrameSduHeader<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for KFrameSduHeader<S>

where S: Storage,

type Ok = KFrameSduHeader<S, OkState>

fn check_ok(self) -> Result<<KFrameSduHeader<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for KFrameSduHeaderWriter<S, CompleteState>

where S: MutStorage,

type Ok = KFrameSduHeaderWriter<S, OkState>

fn check_ok( self, ) -> Result<<KFrameSduHeaderWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for KFrameSduHeaderWriter<S, OkState>

where S: MutStorage,

type Ok = KFrameSduHeaderWriter<S, OkState>

fn check_ok( self, ) -> Result<<KFrameSduHeaderWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for KFrameSduHeaderWriter<S>

where S: MutStorage,

type Ok = KFrameSduHeaderWriter<S, OkState>

fn check_ok(self) -> Result<<KFrameSduHeaderWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capCommandRejectRsp<S, CompleteState>

where S: Storage,

type Ok = L2capCommandRejectRsp<S, OkState>

fn check_ok( self, ) -> Result<<L2capCommandRejectRsp<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capCommandRejectRsp<S, OkState>

where S: Storage,

type Ok = L2capCommandRejectRsp<S, OkState>

fn check_ok( self, ) -> Result<<L2capCommandRejectRsp<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capCommandRejectRsp<S>

where S: Storage,

type Ok = L2capCommandRejectRsp<S, OkState>

fn check_ok(self) -> Result<<L2capCommandRejectRsp<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capCommandRejectRspWriter<S, CompleteState>

where S: MutStorage,

type Ok = L2capCommandRejectRspWriter<S, OkState>

fn check_ok( self, ) -> Result<<L2capCommandRejectRspWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capCommandRejectRspWriter<S, OkState>

where S: MutStorage,

type Ok = L2capCommandRejectRspWriter<S, OkState>

fn check_ok( self, ) -> Result<<L2capCommandRejectRspWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capCommandRejectRspWriter<S>

where S: MutStorage,

type Ok = L2capCommandRejectRspWriter<S, OkState>

fn check_ok( self, ) -> Result<<L2capCommandRejectRspWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capConfigurationOptionHeader<S, CompleteState>

where S: Storage,

type Ok = L2capConfigurationOptionHeader<S, OkState>

fn check_ok( self, ) -> Result<<L2capConfigurationOptionHeader<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capConfigurationOptionHeader<S, OkState>

where S: Storage,

type Ok = L2capConfigurationOptionHeader<S, OkState>

fn check_ok( self, ) -> Result<<L2capConfigurationOptionHeader<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capConfigurationOptionHeader<S>

where S: Storage,

type Ok = L2capConfigurationOptionHeader<S, OkState>

fn check_ok( self, ) -> Result<<L2capConfigurationOptionHeader<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capConfigurationOptionHeaderWriter<S, CompleteState>

where S: MutStorage,

type Ok = L2capConfigurationOptionHeaderWriter<S, OkState>

fn check_ok( self, ) -> Result<<L2capConfigurationOptionHeaderWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capConfigurationOptionHeaderWriter<S, OkState>

where S: MutStorage,

type Ok = L2capConfigurationOptionHeaderWriter<S, OkState>

fn check_ok( self, ) -> Result<<L2capConfigurationOptionHeaderWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capConfigurationOptionHeaderWriter<S>

where S: MutStorage,

type Ok = L2capConfigurationOptionHeaderWriter<S, OkState>

fn check_ok( self, ) -> Result<<L2capConfigurationOptionHeaderWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capConfigureReq<S, CompleteState>

where S: Storage,

type Ok = L2capConfigureReq<S, OkState>

fn check_ok( self, ) -> Result<<L2capConfigureReq<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capConfigureReq<S, OkState>

where S: Storage,

type Ok = L2capConfigureReq<S, OkState>

fn check_ok( self, ) -> Result<<L2capConfigureReq<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capConfigureReq<S>

where S: Storage,

type Ok = L2capConfigureReq<S, OkState>

fn check_ok(self) -> Result<<L2capConfigureReq<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capConfigureReqWriter<S, CompleteState>

where S: MutStorage,

type Ok = L2capConfigureReqWriter<S, OkState>

fn check_ok( self, ) -> Result<<L2capConfigureReqWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capConfigureReqWriter<S, OkState>

where S: MutStorage,

type Ok = L2capConfigureReqWriter<S, OkState>

fn check_ok( self, ) -> Result<<L2capConfigureReqWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capConfigureReqWriter<S>

where S: MutStorage,

type Ok = L2capConfigureReqWriter<S, OkState>

fn check_ok(self) -> Result<<L2capConfigureReqWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capConfigureReq_EmbossReservedAnonymousField2<S, CompleteState>

where S: Storage,

type Ok = L2capConfigureReq_EmbossReservedAnonymousField2<S, OkState>

fn check_ok( self, ) -> Result<<L2capConfigureReq_EmbossReservedAnonymousField2<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capConfigureReq_EmbossReservedAnonymousField2<S, OkState>

where S: Storage,

type Ok = L2capConfigureReq_EmbossReservedAnonymousField2<S, OkState>

fn check_ok( self, ) -> Result<<L2capConfigureReq_EmbossReservedAnonymousField2<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capConfigureReq_EmbossReservedAnonymousField2<S>

where S: Storage,

type Ok = L2capConfigureReq_EmbossReservedAnonymousField2<S, OkState>

fn check_ok( self, ) -> Result<<L2capConfigureReq_EmbossReservedAnonymousField2<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capConfigureReq_EmbossReservedAnonymousField2Writer<S, CompleteState>

where S: MutStorage,

type Ok = L2capConfigureReq_EmbossReservedAnonymousField2Writer<S, OkState>

fn check_ok( self, ) -> Result<<L2capConfigureReq_EmbossReservedAnonymousField2Writer<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capConfigureReq_EmbossReservedAnonymousField2Writer<S, OkState>

where S: MutStorage,

type Ok = L2capConfigureReq_EmbossReservedAnonymousField2Writer<S, OkState>

fn check_ok( self, ) -> Result<<L2capConfigureReq_EmbossReservedAnonymousField2Writer<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capConfigureReq_EmbossReservedAnonymousField2Writer<S>

where S: MutStorage,

type Ok = L2capConfigureReq_EmbossReservedAnonymousField2Writer<S, OkState>

fn check_ok( self, ) -> Result<<L2capConfigureReq_EmbossReservedAnonymousField2Writer<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capConfigureRsp<S, CompleteState>

where S: Storage,

type Ok = L2capConfigureRsp<S, OkState>

fn check_ok( self, ) -> Result<<L2capConfigureRsp<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capConfigureRsp<S, OkState>

where S: Storage,

type Ok = L2capConfigureRsp<S, OkState>

fn check_ok( self, ) -> Result<<L2capConfigureRsp<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capConfigureRsp<S>

where S: Storage,

type Ok = L2capConfigureRsp<S, OkState>

fn check_ok(self) -> Result<<L2capConfigureRsp<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capConfigureRspWriter<S, CompleteState>

where S: MutStorage,

type Ok = L2capConfigureRspWriter<S, OkState>

fn check_ok( self, ) -> Result<<L2capConfigureRspWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capConfigureRspWriter<S, OkState>

where S: MutStorage,

type Ok = L2capConfigureRspWriter<S, OkState>

fn check_ok( self, ) -> Result<<L2capConfigureRspWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capConfigureRspWriter<S>

where S: MutStorage,

type Ok = L2capConfigureRspWriter<S, OkState>

fn check_ok(self) -> Result<<L2capConfigureRspWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capConfigureRsp_EmbossReservedAnonymousField1<S, CompleteState>

where S: Storage,

type Ok = L2capConfigureRsp_EmbossReservedAnonymousField1<S, OkState>

fn check_ok( self, ) -> Result<<L2capConfigureRsp_EmbossReservedAnonymousField1<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capConfigureRsp_EmbossReservedAnonymousField1<S, OkState>

where S: Storage,

type Ok = L2capConfigureRsp_EmbossReservedAnonymousField1<S, OkState>

fn check_ok( self, ) -> Result<<L2capConfigureRsp_EmbossReservedAnonymousField1<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capConfigureRsp_EmbossReservedAnonymousField1<S>

where S: Storage,

type Ok = L2capConfigureRsp_EmbossReservedAnonymousField1<S, OkState>

fn check_ok( self, ) -> Result<<L2capConfigureRsp_EmbossReservedAnonymousField1<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capConfigureRsp_EmbossReservedAnonymousField1Writer<S, CompleteState>

where S: MutStorage,

type Ok = L2capConfigureRsp_EmbossReservedAnonymousField1Writer<S, OkState>

fn check_ok( self, ) -> Result<<L2capConfigureRsp_EmbossReservedAnonymousField1Writer<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capConfigureRsp_EmbossReservedAnonymousField1Writer<S, OkState>

where S: MutStorage,

type Ok = L2capConfigureRsp_EmbossReservedAnonymousField1Writer<S, OkState>

fn check_ok( self, ) -> Result<<L2capConfigureRsp_EmbossReservedAnonymousField1Writer<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capConfigureRsp_EmbossReservedAnonymousField1Writer<S>

where S: MutStorage,

type Ok = L2capConfigureRsp_EmbossReservedAnonymousField1Writer<S, OkState>

fn check_ok( self, ) -> Result<<L2capConfigureRsp_EmbossReservedAnonymousField1Writer<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capConnectionReq<S, CompleteState>

where S: Storage,

type Ok = L2capConnectionReq<S, OkState>

fn check_ok( self, ) -> Result<<L2capConnectionReq<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capConnectionReq<S, OkState>

where S: Storage,

type Ok = L2capConnectionReq<S, OkState>

fn check_ok( self, ) -> Result<<L2capConnectionReq<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capConnectionReq<S>

where S: Storage,

type Ok = L2capConnectionReq<S, OkState>

fn check_ok(self) -> Result<<L2capConnectionReq<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capConnectionReqWriter<S, CompleteState>

where S: MutStorage,

type Ok = L2capConnectionReqWriter<S, OkState>

fn check_ok( self, ) -> Result<<L2capConnectionReqWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capConnectionReqWriter<S, OkState>

where S: MutStorage,

type Ok = L2capConnectionReqWriter<S, OkState>

fn check_ok( self, ) -> Result<<L2capConnectionReqWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capConnectionReqWriter<S>

where S: MutStorage,

type Ok = L2capConnectionReqWriter<S, OkState>

fn check_ok(self) -> Result<<L2capConnectionReqWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capConnectionRsp<S, CompleteState>

where S: Storage,

type Ok = L2capConnectionRsp<S, OkState>

fn check_ok( self, ) -> Result<<L2capConnectionRsp<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capConnectionRsp<S, OkState>

where S: Storage,

type Ok = L2capConnectionRsp<S, OkState>

fn check_ok( self, ) -> Result<<L2capConnectionRsp<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capConnectionRsp<S>

where S: Storage,

type Ok = L2capConnectionRsp<S, OkState>

fn check_ok(self) -> Result<<L2capConnectionRsp<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capConnectionRspWriter<S, CompleteState>

where S: MutStorage,

type Ok = L2capConnectionRspWriter<S, OkState>

fn check_ok( self, ) -> Result<<L2capConnectionRspWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capConnectionRspWriter<S, OkState>

where S: MutStorage,

type Ok = L2capConnectionRspWriter<S, OkState>

fn check_ok( self, ) -> Result<<L2capConnectionRspWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capConnectionRspWriter<S>

where S: MutStorage,

type Ok = L2capConnectionRspWriter<S, OkState>

fn check_ok(self) -> Result<<L2capConnectionRspWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capDisconnectionReq<S, CompleteState>

where S: Storage,

type Ok = L2capDisconnectionReq<S, OkState>

fn check_ok( self, ) -> Result<<L2capDisconnectionReq<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capDisconnectionReq<S, OkState>

where S: Storage,

type Ok = L2capDisconnectionReq<S, OkState>

fn check_ok( self, ) -> Result<<L2capDisconnectionReq<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capDisconnectionReq<S>

where S: Storage,

type Ok = L2capDisconnectionReq<S, OkState>

fn check_ok(self) -> Result<<L2capDisconnectionReq<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capDisconnectionReqWriter<S, CompleteState>

where S: MutStorage,

type Ok = L2capDisconnectionReqWriter<S, OkState>

fn check_ok( self, ) -> Result<<L2capDisconnectionReqWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capDisconnectionReqWriter<S, OkState>

where S: MutStorage,

type Ok = L2capDisconnectionReqWriter<S, OkState>

fn check_ok( self, ) -> Result<<L2capDisconnectionReqWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capDisconnectionReqWriter<S>

where S: MutStorage,

type Ok = L2capDisconnectionReqWriter<S, OkState>

fn check_ok( self, ) -> Result<<L2capDisconnectionReqWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capDisconnectionRsp<S, CompleteState>

where S: Storage,

type Ok = L2capDisconnectionRsp<S, OkState>

fn check_ok( self, ) -> Result<<L2capDisconnectionRsp<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capDisconnectionRsp<S, OkState>

where S: Storage,

type Ok = L2capDisconnectionRsp<S, OkState>

fn check_ok( self, ) -> Result<<L2capDisconnectionRsp<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capDisconnectionRsp<S>

where S: Storage,

type Ok = L2capDisconnectionRsp<S, OkState>

fn check_ok(self) -> Result<<L2capDisconnectionRsp<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capDisconnectionRspWriter<S, CompleteState>

where S: MutStorage,

type Ok = L2capDisconnectionRspWriter<S, OkState>

fn check_ok( self, ) -> Result<<L2capDisconnectionRspWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capDisconnectionRspWriter<S, OkState>

where S: MutStorage,

type Ok = L2capDisconnectionRspWriter<S, OkState>

fn check_ok( self, ) -> Result<<L2capDisconnectionRspWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capDisconnectionRspWriter<S>

where S: MutStorage,

type Ok = L2capDisconnectionRspWriter<S, OkState>

fn check_ok( self, ) -> Result<<L2capDisconnectionRspWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capFlowControlCreditInd<S, CompleteState>

where S: Storage,

type Ok = L2capFlowControlCreditInd<S, OkState>

fn check_ok( self, ) -> Result<<L2capFlowControlCreditInd<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capFlowControlCreditInd<S, OkState>

where S: Storage,

type Ok = L2capFlowControlCreditInd<S, OkState>

fn check_ok( self, ) -> Result<<L2capFlowControlCreditInd<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capFlowControlCreditInd<S>

where S: Storage,

type Ok = L2capFlowControlCreditInd<S, OkState>

fn check_ok( self, ) -> Result<<L2capFlowControlCreditInd<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capFlowControlCreditIndWriter<S, CompleteState>

where S: MutStorage,

type Ok = L2capFlowControlCreditIndWriter<S, OkState>

fn check_ok( self, ) -> Result<<L2capFlowControlCreditIndWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capFlowControlCreditIndWriter<S, OkState>

where S: MutStorage,

type Ok = L2capFlowControlCreditIndWriter<S, OkState>

fn check_ok( self, ) -> Result<<L2capFlowControlCreditIndWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capFlowControlCreditIndWriter<S>

where S: MutStorage,

type Ok = L2capFlowControlCreditIndWriter<S, OkState>

fn check_ok( self, ) -> Result<<L2capFlowControlCreditIndWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capLeCreditBasedConnectionReq<S, CompleteState>

where S: Storage,

type Ok = L2capLeCreditBasedConnectionReq<S, OkState>

fn check_ok( self, ) -> Result<<L2capLeCreditBasedConnectionReq<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capLeCreditBasedConnectionReq<S, OkState>

where S: Storage,

type Ok = L2capLeCreditBasedConnectionReq<S, OkState>

fn check_ok( self, ) -> Result<<L2capLeCreditBasedConnectionReq<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capLeCreditBasedConnectionReq<S>

where S: Storage,

type Ok = L2capLeCreditBasedConnectionReq<S, OkState>

fn check_ok( self, ) -> Result<<L2capLeCreditBasedConnectionReq<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capLeCreditBasedConnectionReqWriter<S, CompleteState>

where S: MutStorage,

type Ok = L2capLeCreditBasedConnectionReqWriter<S, OkState>

fn check_ok( self, ) -> Result<<L2capLeCreditBasedConnectionReqWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capLeCreditBasedConnectionReqWriter<S, OkState>

where S: MutStorage,

type Ok = L2capLeCreditBasedConnectionReqWriter<S, OkState>

fn check_ok( self, ) -> Result<<L2capLeCreditBasedConnectionReqWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capLeCreditBasedConnectionReqWriter<S>

where S: MutStorage,

type Ok = L2capLeCreditBasedConnectionReqWriter<S, OkState>

fn check_ok( self, ) -> Result<<L2capLeCreditBasedConnectionReqWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capMtuConfigurationOption<S, CompleteState>

where S: Storage,

type Ok = L2capMtuConfigurationOption<S, OkState>

fn check_ok( self, ) -> Result<<L2capMtuConfigurationOption<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capMtuConfigurationOption<S, OkState>

where S: Storage,

type Ok = L2capMtuConfigurationOption<S, OkState>

fn check_ok( self, ) -> Result<<L2capMtuConfigurationOption<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capMtuConfigurationOption<S>

where S: Storage,

type Ok = L2capMtuConfigurationOption<S, OkState>

fn check_ok( self, ) -> Result<<L2capMtuConfigurationOption<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capMtuConfigurationOptionWriter<S, CompleteState>

where S: MutStorage,

type Ok = L2capMtuConfigurationOptionWriter<S, OkState>

fn check_ok( self, ) -> Result<<L2capMtuConfigurationOptionWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capMtuConfigurationOptionWriter<S, OkState>

where S: MutStorage,

type Ok = L2capMtuConfigurationOptionWriter<S, OkState>

fn check_ok( self, ) -> Result<<L2capMtuConfigurationOptionWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capMtuConfigurationOptionWriter<S>

where S: MutStorage,

type Ok = L2capMtuConfigurationOptionWriter<S, OkState>

fn check_ok( self, ) -> Result<<L2capMtuConfigurationOptionWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capSignalingCommand<S, CompleteState>

where S: Storage,

type Ok = L2capSignalingCommand<S, OkState>

fn check_ok( self, ) -> Result<<L2capSignalingCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capSignalingCommand<S, OkState>

where S: Storage,

type Ok = L2capSignalingCommand<S, OkState>

fn check_ok( self, ) -> Result<<L2capSignalingCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capSignalingCommand<S>

where S: Storage,

type Ok = L2capSignalingCommand<S, OkState>

fn check_ok(self) -> Result<<L2capSignalingCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capSignalingCommandHeader<S, CompleteState>

where S: Storage,

type Ok = L2capSignalingCommandHeader<S, OkState>

fn check_ok( self, ) -> Result<<L2capSignalingCommandHeader<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capSignalingCommandHeader<S, OkState>

where S: Storage,

type Ok = L2capSignalingCommandHeader<S, OkState>

fn check_ok( self, ) -> Result<<L2capSignalingCommandHeader<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capSignalingCommandHeader<S>

where S: Storage,

type Ok = L2capSignalingCommandHeader<S, OkState>

fn check_ok( self, ) -> Result<<L2capSignalingCommandHeader<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capSignalingCommandHeaderWriter<S, CompleteState>

where S: MutStorage,

type Ok = L2capSignalingCommandHeaderWriter<S, OkState>

fn check_ok( self, ) -> Result<<L2capSignalingCommandHeaderWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capSignalingCommandHeaderWriter<S, OkState>

where S: MutStorage,

type Ok = L2capSignalingCommandHeaderWriter<S, OkState>

fn check_ok( self, ) -> Result<<L2capSignalingCommandHeaderWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capSignalingCommandHeaderWriter<S>

where S: MutStorage,

type Ok = L2capSignalingCommandHeaderWriter<S, OkState>

fn check_ok( self, ) -> Result<<L2capSignalingCommandHeaderWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capSignalingCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = L2capSignalingCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<L2capSignalingCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capSignalingCommandWriter<S, OkState>

where S: MutStorage,

type Ok = L2capSignalingCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<L2capSignalingCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for L2capSignalingCommandWriter<S>

where S: MutStorage,

type Ok = L2capSignalingCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<L2capSignalingCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEAcceptCISRequestCommand<S, CompleteState>

where S: Storage,

type Ok = LEAcceptCISRequestCommand<S, OkState>

fn check_ok( self, ) -> Result<<LEAcceptCISRequestCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEAcceptCISRequestCommand<S, OkState>

where S: Storage,

type Ok = LEAcceptCISRequestCommand<S, OkState>

fn check_ok( self, ) -> Result<<LEAcceptCISRequestCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEAcceptCISRequestCommand<S>

where S: Storage,

type Ok = LEAcceptCISRequestCommand<S, OkState>

fn check_ok( self, ) -> Result<<LEAcceptCISRequestCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEAcceptCISRequestCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = LEAcceptCISRequestCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEAcceptCISRequestCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEAcceptCISRequestCommandWriter<S, OkState>

where S: MutStorage,

type Ok = LEAcceptCISRequestCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEAcceptCISRequestCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEAcceptCISRequestCommandWriter<S>

where S: MutStorage,

type Ok = LEAcceptCISRequestCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEAcceptCISRequestCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEAddDeviceToFilterAcceptListCommand<S, CompleteState>

where S: Storage,

type Ok = LEAddDeviceToFilterAcceptListCommand<S, OkState>

fn check_ok( self, ) -> Result<<LEAddDeviceToFilterAcceptListCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEAddDeviceToFilterAcceptListCommand<S, OkState>

where S: Storage,

type Ok = LEAddDeviceToFilterAcceptListCommand<S, OkState>

fn check_ok( self, ) -> Result<<LEAddDeviceToFilterAcceptListCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEAddDeviceToFilterAcceptListCommand<S>

where S: Storage,

type Ok = LEAddDeviceToFilterAcceptListCommand<S, OkState>

fn check_ok( self, ) -> Result<<LEAddDeviceToFilterAcceptListCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEAddDeviceToFilterAcceptListCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = LEAddDeviceToFilterAcceptListCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEAddDeviceToFilterAcceptListCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEAddDeviceToFilterAcceptListCommandWriter<S, OkState>

where S: MutStorage,

type Ok = LEAddDeviceToFilterAcceptListCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEAddDeviceToFilterAcceptListCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEAddDeviceToFilterAcceptListCommandWriter<S>

where S: MutStorage,

type Ok = LEAddDeviceToFilterAcceptListCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEAddDeviceToFilterAcceptListCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEAddDeviceToPeriodicAdvertiserListCommand<S, CompleteState>

where S: Storage,

type Ok = LEAddDeviceToPeriodicAdvertiserListCommand<S, OkState>

fn check_ok( self, ) -> Result<<LEAddDeviceToPeriodicAdvertiserListCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEAddDeviceToPeriodicAdvertiserListCommand<S, OkState>

where S: Storage,

type Ok = LEAddDeviceToPeriodicAdvertiserListCommand<S, OkState>

fn check_ok( self, ) -> Result<<LEAddDeviceToPeriodicAdvertiserListCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEAddDeviceToPeriodicAdvertiserListCommand<S>

where S: Storage,

type Ok = LEAddDeviceToPeriodicAdvertiserListCommand<S, OkState>

fn check_ok( self, ) -> Result<<LEAddDeviceToPeriodicAdvertiserListCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEAddDeviceToPeriodicAdvertiserListCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = LEAddDeviceToPeriodicAdvertiserListCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEAddDeviceToPeriodicAdvertiserListCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEAddDeviceToPeriodicAdvertiserListCommandWriter<S, OkState>

where S: MutStorage,

type Ok = LEAddDeviceToPeriodicAdvertiserListCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEAddDeviceToPeriodicAdvertiserListCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEAddDeviceToPeriodicAdvertiserListCommandWriter<S>

where S: MutStorage,

type Ok = LEAddDeviceToPeriodicAdvertiserListCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEAddDeviceToPeriodicAdvertiserListCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEAdvertisingChannels<S, CompleteState>

where S: Storage,

type Ok = LEAdvertisingChannels<S, OkState>

fn check_ok( self, ) -> Result<<LEAdvertisingChannels<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEAdvertisingChannels<S, OkState>

where S: Storage,

type Ok = LEAdvertisingChannels<S, OkState>

fn check_ok( self, ) -> Result<<LEAdvertisingChannels<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEAdvertisingChannels<S>

where S: Storage,

type Ok = LEAdvertisingChannels<S, OkState>

fn check_ok(self) -> Result<<LEAdvertisingChannels<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEAdvertisingChannelsWriter<S, CompleteState>

where S: MutStorage,

type Ok = LEAdvertisingChannelsWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEAdvertisingChannelsWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEAdvertisingChannelsWriter<S, OkState>

where S: MutStorage,

type Ok = LEAdvertisingChannelsWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEAdvertisingChannelsWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEAdvertisingChannelsWriter<S>

where S: MutStorage,

type Ok = LEAdvertisingChannelsWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEAdvertisingChannelsWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEAdvertisingEventProperties<S, CompleteState>

where S: Storage,

type Ok = LEAdvertisingEventProperties<S, OkState>

fn check_ok( self, ) -> Result<<LEAdvertisingEventProperties<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEAdvertisingEventProperties<S, OkState>

where S: Storage,

type Ok = LEAdvertisingEventProperties<S, OkState>

fn check_ok( self, ) -> Result<<LEAdvertisingEventProperties<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEAdvertisingEventProperties<S>

where S: Storage,

type Ok = LEAdvertisingEventProperties<S, OkState>

fn check_ok( self, ) -> Result<<LEAdvertisingEventProperties<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEAdvertisingEventPropertiesWriter<S, CompleteState>

where S: MutStorage,

type Ok = LEAdvertisingEventPropertiesWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEAdvertisingEventPropertiesWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEAdvertisingEventPropertiesWriter<S, OkState>

where S: MutStorage,

type Ok = LEAdvertisingEventPropertiesWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEAdvertisingEventPropertiesWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEAdvertisingEventPropertiesWriter<S>

where S: MutStorage,

type Ok = LEAdvertisingEventPropertiesWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEAdvertisingEventPropertiesWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEAdvertisingEventProperties_EmbossReservedAnonymousField18<S, CompleteState>

where S: Storage,

type Ok = LEAdvertisingEventProperties_EmbossReservedAnonymousField18<S, OkState>

fn check_ok( self, ) -> Result<<LEAdvertisingEventProperties_EmbossReservedAnonymousField18<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEAdvertisingEventProperties_EmbossReservedAnonymousField18<S, OkState>

where S: Storage,

type Ok = LEAdvertisingEventProperties_EmbossReservedAnonymousField18<S, OkState>

fn check_ok( self, ) -> Result<<LEAdvertisingEventProperties_EmbossReservedAnonymousField18<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEAdvertisingEventProperties_EmbossReservedAnonymousField18<S>

where S: Storage,

type Ok = LEAdvertisingEventProperties_EmbossReservedAnonymousField18<S, OkState>

fn check_ok( self, ) -> Result<<LEAdvertisingEventProperties_EmbossReservedAnonymousField18<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEAdvertisingEventProperties_EmbossReservedAnonymousField18Writer<S, CompleteState>

where S: MutStorage,

type Ok = LEAdvertisingEventProperties_EmbossReservedAnonymousField18Writer<S, OkState>

fn check_ok( self, ) -> Result<<LEAdvertisingEventProperties_EmbossReservedAnonymousField18Writer<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEAdvertisingEventProperties_EmbossReservedAnonymousField18Writer<S, OkState>

where S: MutStorage,

type Ok = LEAdvertisingEventProperties_EmbossReservedAnonymousField18Writer<S, OkState>

fn check_ok( self, ) -> Result<<LEAdvertisingEventProperties_EmbossReservedAnonymousField18Writer<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEAdvertisingEventProperties_EmbossReservedAnonymousField18Writer<S>

where S: MutStorage,

type Ok = LEAdvertisingEventProperties_EmbossReservedAnonymousField18Writer<S, OkState>

fn check_ok( self, ) -> Result<<LEAdvertisingEventProperties_EmbossReservedAnonymousField18Writer<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LECISPHYOptions<S, CompleteState>

where S: Storage,

type Ok = LECISPHYOptions<S, OkState>

fn check_ok( self, ) -> Result<<LECISPHYOptions<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LECISPHYOptions<S, OkState>

where S: Storage,

type Ok = LECISPHYOptions<S, OkState>

fn check_ok(self) -> Result<<LECISPHYOptions<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LECISPHYOptions<S>

where S: Storage,

type Ok = LECISPHYOptions<S, OkState>

fn check_ok(self) -> Result<<LECISPHYOptions<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LECISPHYOptionsWriter<S, CompleteState>

where S: MutStorage,

type Ok = LECISPHYOptionsWriter<S, OkState>

fn check_ok( self, ) -> Result<<LECISPHYOptionsWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LECISPHYOptionsWriter<S, OkState>

where S: MutStorage,

type Ok = LECISPHYOptionsWriter<S, OkState>

fn check_ok( self, ) -> Result<<LECISPHYOptionsWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LECISPHYOptionsWriter<S>

where S: MutStorage,

type Ok = LECISPHYOptionsWriter<S, OkState>

fn check_ok(self) -> Result<<LECISPHYOptionsWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEClearAdvertisingSetsCommand<S, CompleteState>

where S: Storage,

type Ok = LEClearAdvertisingSetsCommand<S, OkState>

fn check_ok( self, ) -> Result<<LEClearAdvertisingSetsCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEClearAdvertisingSetsCommand<S, OkState>

where S: Storage,

type Ok = LEClearAdvertisingSetsCommand<S, OkState>

fn check_ok( self, ) -> Result<<LEClearAdvertisingSetsCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEClearAdvertisingSetsCommand<S>

where S: Storage,

type Ok = LEClearAdvertisingSetsCommand<S, OkState>

fn check_ok( self, ) -> Result<<LEClearAdvertisingSetsCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEClearAdvertisingSetsCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = LEClearAdvertisingSetsCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEClearAdvertisingSetsCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEClearAdvertisingSetsCommandWriter<S, OkState>

where S: MutStorage,

type Ok = LEClearAdvertisingSetsCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEClearAdvertisingSetsCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEClearAdvertisingSetsCommandWriter<S>

where S: MutStorage,

type Ok = LEClearAdvertisingSetsCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEClearAdvertisingSetsCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEClearFilterAcceptListCommand<S, CompleteState>

where S: Storage,

type Ok = LEClearFilterAcceptListCommand<S, OkState>

fn check_ok( self, ) -> Result<<LEClearFilterAcceptListCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEClearFilterAcceptListCommand<S, OkState>

where S: Storage,

type Ok = LEClearFilterAcceptListCommand<S, OkState>

fn check_ok( self, ) -> Result<<LEClearFilterAcceptListCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEClearFilterAcceptListCommand<S>

where S: Storage,

type Ok = LEClearFilterAcceptListCommand<S, OkState>

fn check_ok( self, ) -> Result<<LEClearFilterAcceptListCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEClearFilterAcceptListCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = LEClearFilterAcceptListCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEClearFilterAcceptListCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEClearFilterAcceptListCommandWriter<S, OkState>

where S: MutStorage,

type Ok = LEClearFilterAcceptListCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEClearFilterAcceptListCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEClearFilterAcceptListCommandWriter<S>

where S: MutStorage,

type Ok = LEClearFilterAcceptListCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEClearFilterAcceptListCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEClearPeriodicAdvertiserListCommand<S, CompleteState>

where S: Storage,

type Ok = LEClearPeriodicAdvertiserListCommand<S, OkState>

fn check_ok( self, ) -> Result<<LEClearPeriodicAdvertiserListCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEClearPeriodicAdvertiserListCommand<S, OkState>

where S: Storage,

type Ok = LEClearPeriodicAdvertiserListCommand<S, OkState>

fn check_ok( self, ) -> Result<<LEClearPeriodicAdvertiserListCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEClearPeriodicAdvertiserListCommand<S>

where S: Storage,

type Ok = LEClearPeriodicAdvertiserListCommand<S, OkState>

fn check_ok( self, ) -> Result<<LEClearPeriodicAdvertiserListCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEClearPeriodicAdvertiserListCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = LEClearPeriodicAdvertiserListCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEClearPeriodicAdvertiserListCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEClearPeriodicAdvertiserListCommandWriter<S, OkState>

where S: MutStorage,

type Ok = LEClearPeriodicAdvertiserListCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEClearPeriodicAdvertiserListCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEClearPeriodicAdvertiserListCommandWriter<S>

where S: MutStorage,

type Ok = LEClearPeriodicAdvertiserListCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEClearPeriodicAdvertiserListCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEClearResolvingListCommand<S, CompleteState>

where S: Storage,

type Ok = LEClearResolvingListCommand<S, OkState>

fn check_ok( self, ) -> Result<<LEClearResolvingListCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEClearResolvingListCommand<S, OkState>

where S: Storage,

type Ok = LEClearResolvingListCommand<S, OkState>

fn check_ok( self, ) -> Result<<LEClearResolvingListCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEClearResolvingListCommand<S>

where S: Storage,

type Ok = LEClearResolvingListCommand<S, OkState>

fn check_ok( self, ) -> Result<<LEClearResolvingListCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEClearResolvingListCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = LEClearResolvingListCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEClearResolvingListCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEClearResolvingListCommandWriter<S, OkState>

where S: MutStorage,

type Ok = LEClearResolvingListCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEClearResolvingListCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEClearResolvingListCommandWriter<S>

where S: MutStorage,

type Ok = LEClearResolvingListCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEClearResolvingListCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEConnectionUpdateCommand<S, CompleteState>

where S: Storage,

type Ok = LEConnectionUpdateCommand<S, OkState>

fn check_ok( self, ) -> Result<<LEConnectionUpdateCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEConnectionUpdateCommand<S, OkState>

where S: Storage,

type Ok = LEConnectionUpdateCommand<S, OkState>

fn check_ok( self, ) -> Result<<LEConnectionUpdateCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEConnectionUpdateCommand<S>

where S: Storage,

type Ok = LEConnectionUpdateCommand<S, OkState>

fn check_ok( self, ) -> Result<<LEConnectionUpdateCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEConnectionUpdateCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = LEConnectionUpdateCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEConnectionUpdateCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEConnectionUpdateCommandWriter<S, OkState>

where S: MutStorage,

type Ok = LEConnectionUpdateCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEConnectionUpdateCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEConnectionUpdateCommandWriter<S>

where S: MutStorage,

type Ok = LEConnectionUpdateCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEConnectionUpdateCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LECreateCISCommand<S, CompleteState>

where S: Storage,

type Ok = LECreateCISCommand<S, OkState>

fn check_ok( self, ) -> Result<<LECreateCISCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LECreateCISCommand<S, OkState>

where S: Storage,

type Ok = LECreateCISCommand<S, OkState>

fn check_ok( self, ) -> Result<<LECreateCISCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LECreateCISCommand<S>

where S: Storage,

type Ok = LECreateCISCommand<S, OkState>

fn check_ok(self) -> Result<<LECreateCISCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LECreateCISCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = LECreateCISCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LECreateCISCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LECreateCISCommandWriter<S, OkState>

where S: MutStorage,

type Ok = LECreateCISCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LECreateCISCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LECreateCISCommandWriter<S>

where S: MutStorage,

type Ok = LECreateCISCommandWriter<S, OkState>

fn check_ok(self) -> Result<<LECreateCISCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LECreateCISCommand_ConnectionInfo<S, CompleteState>

where S: Storage,

type Ok = LECreateCISCommand_ConnectionInfo<S, OkState>

fn check_ok( self, ) -> Result<<LECreateCISCommand_ConnectionInfo<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LECreateCISCommand_ConnectionInfo<S, OkState>

where S: Storage,

type Ok = LECreateCISCommand_ConnectionInfo<S, OkState>

fn check_ok( self, ) -> Result<<LECreateCISCommand_ConnectionInfo<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LECreateCISCommand_ConnectionInfo<S>

where S: Storage,

type Ok = LECreateCISCommand_ConnectionInfo<S, OkState>

fn check_ok( self, ) -> Result<<LECreateCISCommand_ConnectionInfo<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LECreateCISCommand_ConnectionInfoWriter<S, CompleteState>

where S: MutStorage,

type Ok = LECreateCISCommand_ConnectionInfoWriter<S, OkState>

fn check_ok( self, ) -> Result<<LECreateCISCommand_ConnectionInfoWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LECreateCISCommand_ConnectionInfoWriter<S, OkState>

where S: MutStorage,

type Ok = LECreateCISCommand_ConnectionInfoWriter<S, OkState>

fn check_ok( self, ) -> Result<<LECreateCISCommand_ConnectionInfoWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LECreateCISCommand_ConnectionInfoWriter<S>

where S: MutStorage,

type Ok = LECreateCISCommand_ConnectionInfoWriter<S, OkState>

fn check_ok( self, ) -> Result<<LECreateCISCommand_ConnectionInfoWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LECreateConnectionCancelCommand<S, CompleteState>

where S: Storage,

type Ok = LECreateConnectionCancelCommand<S, OkState>

fn check_ok( self, ) -> Result<<LECreateConnectionCancelCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LECreateConnectionCancelCommand<S, OkState>

where S: Storage,

type Ok = LECreateConnectionCancelCommand<S, OkState>

fn check_ok( self, ) -> Result<<LECreateConnectionCancelCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LECreateConnectionCancelCommand<S>

where S: Storage,

type Ok = LECreateConnectionCancelCommand<S, OkState>

fn check_ok( self, ) -> Result<<LECreateConnectionCancelCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LECreateConnectionCancelCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = LECreateConnectionCancelCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LECreateConnectionCancelCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LECreateConnectionCancelCommandWriter<S, OkState>

where S: MutStorage,

type Ok = LECreateConnectionCancelCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LECreateConnectionCancelCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LECreateConnectionCancelCommandWriter<S>

where S: MutStorage,

type Ok = LECreateConnectionCancelCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LECreateConnectionCancelCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LECreateConnectionCommand<S, CompleteState>

where S: Storage,

type Ok = LECreateConnectionCommand<S, OkState>

fn check_ok( self, ) -> Result<<LECreateConnectionCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LECreateConnectionCommand<S, OkState>

where S: Storage,

type Ok = LECreateConnectionCommand<S, OkState>

fn check_ok( self, ) -> Result<<LECreateConnectionCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LECreateConnectionCommand<S>

where S: Storage,

type Ok = LECreateConnectionCommand<S, OkState>

fn check_ok( self, ) -> Result<<LECreateConnectionCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LECreateConnectionCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = LECreateConnectionCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LECreateConnectionCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LECreateConnectionCommandWriter<S, OkState>

where S: MutStorage,

type Ok = LECreateConnectionCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LECreateConnectionCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LECreateConnectionCommandWriter<S>

where S: MutStorage,

type Ok = LECreateConnectionCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LECreateConnectionCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEEnableEncryptionCommand<S, CompleteState>

where S: Storage,

type Ok = LEEnableEncryptionCommand<S, OkState>

fn check_ok( self, ) -> Result<<LEEnableEncryptionCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEEnableEncryptionCommand<S, OkState>

where S: Storage,

type Ok = LEEnableEncryptionCommand<S, OkState>

fn check_ok( self, ) -> Result<<LEEnableEncryptionCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEEnableEncryptionCommand<S>

where S: Storage,

type Ok = LEEnableEncryptionCommand<S, OkState>

fn check_ok( self, ) -> Result<<LEEnableEncryptionCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEEnableEncryptionCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = LEEnableEncryptionCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEEnableEncryptionCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEEnableEncryptionCommandWriter<S, OkState>

where S: MutStorage,

type Ok = LEEnableEncryptionCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEEnableEncryptionCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEEnableEncryptionCommandWriter<S>

where S: MutStorage,

type Ok = LEEnableEncryptionCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEEnableEncryptionCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEEventMask<S, CompleteState>

where S: Storage,

type Ok = LEEventMask<S, OkState>

fn check_ok( self, ) -> Result<<LEEventMask<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEEventMask<S, OkState>

where S: Storage,

type Ok = LEEventMask<S, OkState>

fn check_ok(self) -> Result<<LEEventMask<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEEventMask<S>

where S: Storage,

type Ok = LEEventMask<S, OkState>

fn check_ok(self) -> Result<<LEEventMask<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEEventMaskWriter<S, CompleteState>

where S: MutStorage,

type Ok = LEEventMaskWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEEventMaskWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEEventMaskWriter<S, OkState>

where S: MutStorage,

type Ok = LEEventMaskWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEEventMaskWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEEventMaskWriter<S>

where S: MutStorage,

type Ok = LEEventMaskWriter<S, OkState>

fn check_ok(self) -> Result<<LEEventMaskWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEExtendedCreateConnectionCommandV1<S, CompleteState>

where S: Storage,

type Ok = LEExtendedCreateConnectionCommandV1<S, OkState>

fn check_ok( self, ) -> Result<<LEExtendedCreateConnectionCommandV1<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEExtendedCreateConnectionCommandV1<S, OkState>

where S: Storage,

type Ok = LEExtendedCreateConnectionCommandV1<S, OkState>

fn check_ok( self, ) -> Result<<LEExtendedCreateConnectionCommandV1<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEExtendedCreateConnectionCommandV1<S>

where S: Storage,

type Ok = LEExtendedCreateConnectionCommandV1<S, OkState>

fn check_ok( self, ) -> Result<<LEExtendedCreateConnectionCommandV1<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEExtendedCreateConnectionCommandV1Writer<S, CompleteState>

where S: MutStorage,

type Ok = LEExtendedCreateConnectionCommandV1Writer<S, OkState>

fn check_ok( self, ) -> Result<<LEExtendedCreateConnectionCommandV1Writer<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEExtendedCreateConnectionCommandV1Writer<S, OkState>

where S: MutStorage,

type Ok = LEExtendedCreateConnectionCommandV1Writer<S, OkState>

fn check_ok( self, ) -> Result<<LEExtendedCreateConnectionCommandV1Writer<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEExtendedCreateConnectionCommandV1Writer<S>

where S: MutStorage,

type Ok = LEExtendedCreateConnectionCommandV1Writer<S, OkState>

fn check_ok( self, ) -> Result<<LEExtendedCreateConnectionCommandV1Writer<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEExtendedCreateConnectionCommandV1_EmbossReservedAnonymousField6<S, CompleteState>

where S: Storage,

type Ok = LEExtendedCreateConnectionCommandV1_EmbossReservedAnonymousField6<S, OkState>

fn check_ok( self, ) -> Result<<LEExtendedCreateConnectionCommandV1_EmbossReservedAnonymousField6<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEExtendedCreateConnectionCommandV1_EmbossReservedAnonymousField6<S, OkState>

where S: Storage,

type Ok = LEExtendedCreateConnectionCommandV1_EmbossReservedAnonymousField6<S, OkState>

fn check_ok( self, ) -> Result<<LEExtendedCreateConnectionCommandV1_EmbossReservedAnonymousField6<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEExtendedCreateConnectionCommandV1_EmbossReservedAnonymousField6<S>

where S: Storage,

type Ok = LEExtendedCreateConnectionCommandV1_EmbossReservedAnonymousField6<S, OkState>

fn check_ok( self, ) -> Result<<LEExtendedCreateConnectionCommandV1_EmbossReservedAnonymousField6<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEExtendedCreateConnectionCommandV1_EmbossReservedAnonymousField6Writer<S, CompleteState>

where S: MutStorage,

type Ok = LEExtendedCreateConnectionCommandV1_EmbossReservedAnonymousField6Writer<S, OkState>

fn check_ok( self, ) -> Result<<LEExtendedCreateConnectionCommandV1_EmbossReservedAnonymousField6Writer<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEExtendedCreateConnectionCommandV1_EmbossReservedAnonymousField6Writer<S, OkState>

where S: MutStorage,

type Ok = LEExtendedCreateConnectionCommandV1_EmbossReservedAnonymousField6Writer<S, OkState>

fn check_ok( self, ) -> Result<<LEExtendedCreateConnectionCommandV1_EmbossReservedAnonymousField6Writer<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEExtendedCreateConnectionCommandV1_EmbossReservedAnonymousField6Writer<S>

where S: MutStorage,

type Ok = LEExtendedCreateConnectionCommandV1_EmbossReservedAnonymousField6Writer<S, OkState>

fn check_ok( self, ) -> Result<<LEExtendedCreateConnectionCommandV1_EmbossReservedAnonymousField6Writer<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEExtendedCreateConnectionData<S, CompleteState>

where S: Storage,

type Ok = LEExtendedCreateConnectionData<S, OkState>

fn check_ok( self, ) -> Result<<LEExtendedCreateConnectionData<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEExtendedCreateConnectionData<S, OkState>

where S: Storage,

type Ok = LEExtendedCreateConnectionData<S, OkState>

fn check_ok( self, ) -> Result<<LEExtendedCreateConnectionData<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEExtendedCreateConnectionData<S>

where S: Storage,

type Ok = LEExtendedCreateConnectionData<S, OkState>

fn check_ok( self, ) -> Result<<LEExtendedCreateConnectionData<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEExtendedCreateConnectionDataWriter<S, CompleteState>

where S: MutStorage,

type Ok = LEExtendedCreateConnectionDataWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEExtendedCreateConnectionDataWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEExtendedCreateConnectionDataWriter<S, OkState>

where S: MutStorage,

type Ok = LEExtendedCreateConnectionDataWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEExtendedCreateConnectionDataWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEExtendedCreateConnectionDataWriter<S>

where S: MutStorage,

type Ok = LEExtendedCreateConnectionDataWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEExtendedCreateConnectionDataWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEInitiatingPHYBits<S, CompleteState>

where S: Storage,

type Ok = LEInitiatingPHYBits<S, OkState>

fn check_ok( self, ) -> Result<<LEInitiatingPHYBits<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEInitiatingPHYBits<S, OkState>

where S: Storage,

type Ok = LEInitiatingPHYBits<S, OkState>

fn check_ok( self, ) -> Result<<LEInitiatingPHYBits<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEInitiatingPHYBits<S>

where S: Storage,

type Ok = LEInitiatingPHYBits<S, OkState>

fn check_ok(self) -> Result<<LEInitiatingPHYBits<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEInitiatingPHYBitsWriter<S, CompleteState>

where S: MutStorage,

type Ok = LEInitiatingPHYBitsWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEInitiatingPHYBitsWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEInitiatingPHYBitsWriter<S, OkState>

where S: MutStorage,

type Ok = LEInitiatingPHYBitsWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEInitiatingPHYBitsWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEInitiatingPHYBitsWriter<S>

where S: MutStorage,

type Ok = LEInitiatingPHYBitsWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEInitiatingPHYBitsWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LELongTermKeyRequestNegativeReplyCommand<S, CompleteState>

where S: Storage,

type Ok = LELongTermKeyRequestNegativeReplyCommand<S, OkState>

fn check_ok( self, ) -> Result<<LELongTermKeyRequestNegativeReplyCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LELongTermKeyRequestNegativeReplyCommand<S, OkState>

where S: Storage,

type Ok = LELongTermKeyRequestNegativeReplyCommand<S, OkState>

fn check_ok( self, ) -> Result<<LELongTermKeyRequestNegativeReplyCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LELongTermKeyRequestNegativeReplyCommand<S>

where S: Storage,

type Ok = LELongTermKeyRequestNegativeReplyCommand<S, OkState>

fn check_ok( self, ) -> Result<<LELongTermKeyRequestNegativeReplyCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LELongTermKeyRequestNegativeReplyCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = LELongTermKeyRequestNegativeReplyCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LELongTermKeyRequestNegativeReplyCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LELongTermKeyRequestNegativeReplyCommandWriter<S, OkState>

where S: MutStorage,

type Ok = LELongTermKeyRequestNegativeReplyCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LELongTermKeyRequestNegativeReplyCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LELongTermKeyRequestNegativeReplyCommandWriter<S>

where S: MutStorage,

type Ok = LELongTermKeyRequestNegativeReplyCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LELongTermKeyRequestNegativeReplyCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LELongTermKeyRequestReplyCommand<S, CompleteState>

where S: Storage,

type Ok = LELongTermKeyRequestReplyCommand<S, OkState>

fn check_ok( self, ) -> Result<<LELongTermKeyRequestReplyCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LELongTermKeyRequestReplyCommand<S, OkState>

where S: Storage,

type Ok = LELongTermKeyRequestReplyCommand<S, OkState>

fn check_ok( self, ) -> Result<<LELongTermKeyRequestReplyCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LELongTermKeyRequestReplyCommand<S>

where S: Storage,

type Ok = LELongTermKeyRequestReplyCommand<S, OkState>

fn check_ok( self, ) -> Result<<LELongTermKeyRequestReplyCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LELongTermKeyRequestReplyCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = LELongTermKeyRequestReplyCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LELongTermKeyRequestReplyCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LELongTermKeyRequestReplyCommandWriter<S, OkState>

where S: MutStorage,

type Ok = LELongTermKeyRequestReplyCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LELongTermKeyRequestReplyCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LELongTermKeyRequestReplyCommandWriter<S>

where S: MutStorage,

type Ok = LELongTermKeyRequestReplyCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LELongTermKeyRequestReplyCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEPeriodicAdvertisingCreateSyncCancelCommand<S, CompleteState>

where S: Storage,

type Ok = LEPeriodicAdvertisingCreateSyncCancelCommand<S, OkState>

fn check_ok( self, ) -> Result<<LEPeriodicAdvertisingCreateSyncCancelCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEPeriodicAdvertisingCreateSyncCancelCommand<S, OkState>

where S: Storage,

type Ok = LEPeriodicAdvertisingCreateSyncCancelCommand<S, OkState>

fn check_ok( self, ) -> Result<<LEPeriodicAdvertisingCreateSyncCancelCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEPeriodicAdvertisingCreateSyncCancelCommand<S>

where S: Storage,

type Ok = LEPeriodicAdvertisingCreateSyncCancelCommand<S, OkState>

fn check_ok( self, ) -> Result<<LEPeriodicAdvertisingCreateSyncCancelCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEPeriodicAdvertisingCreateSyncCancelCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = LEPeriodicAdvertisingCreateSyncCancelCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEPeriodicAdvertisingCreateSyncCancelCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEPeriodicAdvertisingCreateSyncCancelCommandWriter<S, OkState>

where S: MutStorage,

type Ok = LEPeriodicAdvertisingCreateSyncCancelCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEPeriodicAdvertisingCreateSyncCancelCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEPeriodicAdvertisingCreateSyncCancelCommandWriter<S>

where S: MutStorage,

type Ok = LEPeriodicAdvertisingCreateSyncCancelCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEPeriodicAdvertisingCreateSyncCancelCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEPeriodicAdvertisingCreateSyncCommand<S, CompleteState>

where S: Storage,

type Ok = LEPeriodicAdvertisingCreateSyncCommand<S, OkState>

fn check_ok( self, ) -> Result<<LEPeriodicAdvertisingCreateSyncCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEPeriodicAdvertisingCreateSyncCommand<S, OkState>

where S: Storage,

type Ok = LEPeriodicAdvertisingCreateSyncCommand<S, OkState>

fn check_ok( self, ) -> Result<<LEPeriodicAdvertisingCreateSyncCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEPeriodicAdvertisingCreateSyncCommand<S>

where S: Storage,

type Ok = LEPeriodicAdvertisingCreateSyncCommand<S, OkState>

fn check_ok( self, ) -> Result<<LEPeriodicAdvertisingCreateSyncCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEPeriodicAdvertisingCreateSyncCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = LEPeriodicAdvertisingCreateSyncCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEPeriodicAdvertisingCreateSyncCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEPeriodicAdvertisingCreateSyncCommandWriter<S, OkState>

where S: MutStorage,

type Ok = LEPeriodicAdvertisingCreateSyncCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEPeriodicAdvertisingCreateSyncCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEPeriodicAdvertisingCreateSyncCommandWriter<S>

where S: MutStorage,

type Ok = LEPeriodicAdvertisingCreateSyncCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEPeriodicAdvertisingCreateSyncCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEPeriodicAdvertisingCreateSyncCommand_EmbossReservedAnonymousField4<S, CompleteState>

where S: Storage,

type Ok = LEPeriodicAdvertisingCreateSyncCommand_EmbossReservedAnonymousField4<S, OkState>

fn check_ok( self, ) -> Result<<LEPeriodicAdvertisingCreateSyncCommand_EmbossReservedAnonymousField4<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEPeriodicAdvertisingCreateSyncCommand_EmbossReservedAnonymousField4<S, OkState>

where S: Storage,

type Ok = LEPeriodicAdvertisingCreateSyncCommand_EmbossReservedAnonymousField4<S, OkState>

fn check_ok( self, ) -> Result<<LEPeriodicAdvertisingCreateSyncCommand_EmbossReservedAnonymousField4<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEPeriodicAdvertisingCreateSyncCommand_EmbossReservedAnonymousField4<S>

where S: Storage,

type Ok = LEPeriodicAdvertisingCreateSyncCommand_EmbossReservedAnonymousField4<S, OkState>

fn check_ok( self, ) -> Result<<LEPeriodicAdvertisingCreateSyncCommand_EmbossReservedAnonymousField4<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEPeriodicAdvertisingCreateSyncCommand_EmbossReservedAnonymousField4Writer<S, CompleteState>

where S: MutStorage,

type Ok = LEPeriodicAdvertisingCreateSyncCommand_EmbossReservedAnonymousField4Writer<S, OkState>

fn check_ok( self, ) -> Result<<LEPeriodicAdvertisingCreateSyncCommand_EmbossReservedAnonymousField4Writer<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEPeriodicAdvertisingCreateSyncCommand_EmbossReservedAnonymousField4Writer<S, OkState>

where S: MutStorage,

type Ok = LEPeriodicAdvertisingCreateSyncCommand_EmbossReservedAnonymousField4Writer<S, OkState>

fn check_ok( self, ) -> Result<<LEPeriodicAdvertisingCreateSyncCommand_EmbossReservedAnonymousField4Writer<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEPeriodicAdvertisingCreateSyncCommand_EmbossReservedAnonymousField4Writer<S>

where S: MutStorage,

type Ok = LEPeriodicAdvertisingCreateSyncCommand_EmbossReservedAnonymousField4Writer<S, OkState>

fn check_ok( self, ) -> Result<<LEPeriodicAdvertisingCreateSyncCommand_EmbossReservedAnonymousField4Writer<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEPeriodicAdvertisingCreateSyncCommand_EmbossReservedAnonymousField5<S, CompleteState>

where S: Storage,

type Ok = LEPeriodicAdvertisingCreateSyncCommand_EmbossReservedAnonymousField5<S, OkState>

fn check_ok( self, ) -> Result<<LEPeriodicAdvertisingCreateSyncCommand_EmbossReservedAnonymousField5<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEPeriodicAdvertisingCreateSyncCommand_EmbossReservedAnonymousField5<S, OkState>

where S: Storage,

type Ok = LEPeriodicAdvertisingCreateSyncCommand_EmbossReservedAnonymousField5<S, OkState>

fn check_ok( self, ) -> Result<<LEPeriodicAdvertisingCreateSyncCommand_EmbossReservedAnonymousField5<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEPeriodicAdvertisingCreateSyncCommand_EmbossReservedAnonymousField5<S>

where S: Storage,

type Ok = LEPeriodicAdvertisingCreateSyncCommand_EmbossReservedAnonymousField5<S, OkState>

fn check_ok( self, ) -> Result<<LEPeriodicAdvertisingCreateSyncCommand_EmbossReservedAnonymousField5<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEPeriodicAdvertisingCreateSyncCommand_EmbossReservedAnonymousField5Writer<S, CompleteState>

where S: MutStorage,

type Ok = LEPeriodicAdvertisingCreateSyncCommand_EmbossReservedAnonymousField5Writer<S, OkState>

fn check_ok( self, ) -> Result<<LEPeriodicAdvertisingCreateSyncCommand_EmbossReservedAnonymousField5Writer<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEPeriodicAdvertisingCreateSyncCommand_EmbossReservedAnonymousField5Writer<S, OkState>

where S: MutStorage,

type Ok = LEPeriodicAdvertisingCreateSyncCommand_EmbossReservedAnonymousField5Writer<S, OkState>

fn check_ok( self, ) -> Result<<LEPeriodicAdvertisingCreateSyncCommand_EmbossReservedAnonymousField5Writer<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEPeriodicAdvertisingCreateSyncCommand_EmbossReservedAnonymousField5Writer<S>

where S: MutStorage,

type Ok = LEPeriodicAdvertisingCreateSyncCommand_EmbossReservedAnonymousField5Writer<S, OkState>

fn check_ok( self, ) -> Result<<LEPeriodicAdvertisingCreateSyncCommand_EmbossReservedAnonymousField5Writer<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEPeriodicAdvertisingCreateSyncOptions<S, CompleteState>

where S: Storage,

type Ok = LEPeriodicAdvertisingCreateSyncOptions<S, OkState>

fn check_ok( self, ) -> Result<<LEPeriodicAdvertisingCreateSyncOptions<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEPeriodicAdvertisingCreateSyncOptions<S, OkState>

where S: Storage,

type Ok = LEPeriodicAdvertisingCreateSyncOptions<S, OkState>

fn check_ok( self, ) -> Result<<LEPeriodicAdvertisingCreateSyncOptions<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEPeriodicAdvertisingCreateSyncOptions<S>

where S: Storage,

type Ok = LEPeriodicAdvertisingCreateSyncOptions<S, OkState>

fn check_ok( self, ) -> Result<<LEPeriodicAdvertisingCreateSyncOptions<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEPeriodicAdvertisingCreateSyncOptionsWriter<S, CompleteState>

where S: MutStorage,

type Ok = LEPeriodicAdvertisingCreateSyncOptionsWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEPeriodicAdvertisingCreateSyncOptionsWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEPeriodicAdvertisingCreateSyncOptionsWriter<S, OkState>

where S: MutStorage,

type Ok = LEPeriodicAdvertisingCreateSyncOptionsWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEPeriodicAdvertisingCreateSyncOptionsWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEPeriodicAdvertisingCreateSyncOptionsWriter<S>

where S: MutStorage,

type Ok = LEPeriodicAdvertisingCreateSyncOptionsWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEPeriodicAdvertisingCreateSyncOptionsWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEPeriodicAdvertisingSyncCteType<S, CompleteState>

where S: Storage,

type Ok = LEPeriodicAdvertisingSyncCteType<S, OkState>

fn check_ok( self, ) -> Result<<LEPeriodicAdvertisingSyncCteType<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEPeriodicAdvertisingSyncCteType<S, OkState>

where S: Storage,

type Ok = LEPeriodicAdvertisingSyncCteType<S, OkState>

fn check_ok( self, ) -> Result<<LEPeriodicAdvertisingSyncCteType<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEPeriodicAdvertisingSyncCteType<S>

where S: Storage,

type Ok = LEPeriodicAdvertisingSyncCteType<S, OkState>

fn check_ok( self, ) -> Result<<LEPeriodicAdvertisingSyncCteType<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEPeriodicAdvertisingSyncCteTypeWriter<S, CompleteState>

where S: MutStorage,

type Ok = LEPeriodicAdvertisingSyncCteTypeWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEPeriodicAdvertisingSyncCteTypeWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEPeriodicAdvertisingSyncCteTypeWriter<S, OkState>

where S: MutStorage,

type Ok = LEPeriodicAdvertisingSyncCteTypeWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEPeriodicAdvertisingSyncCteTypeWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEPeriodicAdvertisingSyncCteTypeWriter<S>

where S: MutStorage,

type Ok = LEPeriodicAdvertisingSyncCteTypeWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEPeriodicAdvertisingSyncCteTypeWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEPeriodicAdvertisingSyncTransferCommand<S, CompleteState>

where S: Storage,

type Ok = LEPeriodicAdvertisingSyncTransferCommand<S, OkState>

fn check_ok( self, ) -> Result<<LEPeriodicAdvertisingSyncTransferCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEPeriodicAdvertisingSyncTransferCommand<S, OkState>

where S: Storage,

type Ok = LEPeriodicAdvertisingSyncTransferCommand<S, OkState>

fn check_ok( self, ) -> Result<<LEPeriodicAdvertisingSyncTransferCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEPeriodicAdvertisingSyncTransferCommand<S>

where S: Storage,

type Ok = LEPeriodicAdvertisingSyncTransferCommand<S, OkState>

fn check_ok( self, ) -> Result<<LEPeriodicAdvertisingSyncTransferCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEPeriodicAdvertisingSyncTransferCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = LEPeriodicAdvertisingSyncTransferCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEPeriodicAdvertisingSyncTransferCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEPeriodicAdvertisingSyncTransferCommandWriter<S, OkState>

where S: MutStorage,

type Ok = LEPeriodicAdvertisingSyncTransferCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEPeriodicAdvertisingSyncTransferCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEPeriodicAdvertisingSyncTransferCommandWriter<S>

where S: MutStorage,

type Ok = LEPeriodicAdvertisingSyncTransferCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEPeriodicAdvertisingSyncTransferCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEPeriodicAdvertisingTerminateSyncCommand<S, CompleteState>

where S: Storage,

type Ok = LEPeriodicAdvertisingTerminateSyncCommand<S, OkState>

fn check_ok( self, ) -> Result<<LEPeriodicAdvertisingTerminateSyncCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEPeriodicAdvertisingTerminateSyncCommand<S, OkState>

where S: Storage,

type Ok = LEPeriodicAdvertisingTerminateSyncCommand<S, OkState>

fn check_ok( self, ) -> Result<<LEPeriodicAdvertisingTerminateSyncCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEPeriodicAdvertisingTerminateSyncCommand<S>

where S: Storage,

type Ok = LEPeriodicAdvertisingTerminateSyncCommand<S, OkState>

fn check_ok( self, ) -> Result<<LEPeriodicAdvertisingTerminateSyncCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEPeriodicAdvertisingTerminateSyncCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = LEPeriodicAdvertisingTerminateSyncCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEPeriodicAdvertisingTerminateSyncCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEPeriodicAdvertisingTerminateSyncCommandWriter<S, OkState>

where S: MutStorage,

type Ok = LEPeriodicAdvertisingTerminateSyncCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEPeriodicAdvertisingTerminateSyncCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEPeriodicAdvertisingTerminateSyncCommandWriter<S>

where S: MutStorage,

type Ok = LEPeriodicAdvertisingTerminateSyncCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEPeriodicAdvertisingTerminateSyncCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LERandCommand<S, CompleteState>

where S: Storage,

type Ok = LERandCommand<S, OkState>

fn check_ok( self, ) -> Result<<LERandCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LERandCommand<S, OkState>

where S: Storage,

type Ok = LERandCommand<S, OkState>

fn check_ok(self) -> Result<<LERandCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LERandCommand<S>

where S: Storage,

type Ok = LERandCommand<S, OkState>

fn check_ok(self) -> Result<<LERandCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LERandCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = LERandCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LERandCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LERandCommandWriter<S, OkState>

where S: MutStorage,

type Ok = LERandCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LERandCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LERandCommandWriter<S>

where S: MutStorage,

type Ok = LERandCommandWriter<S, OkState>

fn check_ok(self) -> Result<<LERandCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEReadAdvertisingChannelTxPowerCommand<S, CompleteState>

where S: Storage,

type Ok = LEReadAdvertisingChannelTxPowerCommand<S, OkState>

fn check_ok( self, ) -> Result<<LEReadAdvertisingChannelTxPowerCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEReadAdvertisingChannelTxPowerCommand<S, OkState>

where S: Storage,

type Ok = LEReadAdvertisingChannelTxPowerCommand<S, OkState>

fn check_ok( self, ) -> Result<<LEReadAdvertisingChannelTxPowerCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEReadAdvertisingChannelTxPowerCommand<S>

where S: Storage,

type Ok = LEReadAdvertisingChannelTxPowerCommand<S, OkState>

fn check_ok( self, ) -> Result<<LEReadAdvertisingChannelTxPowerCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEReadAdvertisingChannelTxPowerCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = LEReadAdvertisingChannelTxPowerCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEReadAdvertisingChannelTxPowerCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEReadAdvertisingChannelTxPowerCommandWriter<S, OkState>

where S: MutStorage,

type Ok = LEReadAdvertisingChannelTxPowerCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEReadAdvertisingChannelTxPowerCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEReadAdvertisingChannelTxPowerCommandWriter<S>

where S: MutStorage,

type Ok = LEReadAdvertisingChannelTxPowerCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEReadAdvertisingChannelTxPowerCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEReadBufferSizeCommandV1<S, CompleteState>

where S: Storage,

type Ok = LEReadBufferSizeCommandV1<S, OkState>

fn check_ok( self, ) -> Result<<LEReadBufferSizeCommandV1<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEReadBufferSizeCommandV1<S, OkState>

where S: Storage,

type Ok = LEReadBufferSizeCommandV1<S, OkState>

fn check_ok( self, ) -> Result<<LEReadBufferSizeCommandV1<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEReadBufferSizeCommandV1<S>

where S: Storage,

type Ok = LEReadBufferSizeCommandV1<S, OkState>

fn check_ok( self, ) -> Result<<LEReadBufferSizeCommandV1<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEReadBufferSizeCommandV1Writer<S, CompleteState>

where S: MutStorage,

type Ok = LEReadBufferSizeCommandV1Writer<S, OkState>

fn check_ok( self, ) -> Result<<LEReadBufferSizeCommandV1Writer<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEReadBufferSizeCommandV1Writer<S, OkState>

where S: MutStorage,

type Ok = LEReadBufferSizeCommandV1Writer<S, OkState>

fn check_ok( self, ) -> Result<<LEReadBufferSizeCommandV1Writer<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEReadBufferSizeCommandV1Writer<S>

where S: MutStorage,

type Ok = LEReadBufferSizeCommandV1Writer<S, OkState>

fn check_ok( self, ) -> Result<<LEReadBufferSizeCommandV1Writer<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEReadBufferSizeCommandV2<S, CompleteState>

where S: Storage,

type Ok = LEReadBufferSizeCommandV2<S, OkState>

fn check_ok( self, ) -> Result<<LEReadBufferSizeCommandV2<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEReadBufferSizeCommandV2<S, OkState>

where S: Storage,

type Ok = LEReadBufferSizeCommandV2<S, OkState>

fn check_ok( self, ) -> Result<<LEReadBufferSizeCommandV2<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEReadBufferSizeCommandV2<S>

where S: Storage,

type Ok = LEReadBufferSizeCommandV2<S, OkState>

fn check_ok( self, ) -> Result<<LEReadBufferSizeCommandV2<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEReadBufferSizeCommandV2Writer<S, CompleteState>

where S: MutStorage,

type Ok = LEReadBufferSizeCommandV2Writer<S, OkState>

fn check_ok( self, ) -> Result<<LEReadBufferSizeCommandV2Writer<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEReadBufferSizeCommandV2Writer<S, OkState>

where S: MutStorage,

type Ok = LEReadBufferSizeCommandV2Writer<S, OkState>

fn check_ok( self, ) -> Result<<LEReadBufferSizeCommandV2Writer<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEReadBufferSizeCommandV2Writer<S>

where S: MutStorage,

type Ok = LEReadBufferSizeCommandV2Writer<S, OkState>

fn check_ok( self, ) -> Result<<LEReadBufferSizeCommandV2Writer<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEReadISOTXSyncCommand<S, CompleteState>

where S: Storage,

type Ok = LEReadISOTXSyncCommand<S, OkState>

fn check_ok( self, ) -> Result<<LEReadISOTXSyncCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEReadISOTXSyncCommand<S, OkState>

where S: Storage,

type Ok = LEReadISOTXSyncCommand<S, OkState>

fn check_ok( self, ) -> Result<<LEReadISOTXSyncCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEReadISOTXSyncCommand<S>

where S: Storage,

type Ok = LEReadISOTXSyncCommand<S, OkState>

fn check_ok(self) -> Result<<LEReadISOTXSyncCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEReadISOTXSyncCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = LEReadISOTXSyncCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEReadISOTXSyncCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEReadISOTXSyncCommandWriter<S, OkState>

where S: MutStorage,

type Ok = LEReadISOTXSyncCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEReadISOTXSyncCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEReadISOTXSyncCommandWriter<S>

where S: MutStorage,

type Ok = LEReadISOTXSyncCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEReadISOTXSyncCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEReadLocalSupportedFeaturesCommand<S, CompleteState>

where S: Storage,

type Ok = LEReadLocalSupportedFeaturesCommand<S, OkState>

fn check_ok( self, ) -> Result<<LEReadLocalSupportedFeaturesCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEReadLocalSupportedFeaturesCommand<S, OkState>

where S: Storage,

type Ok = LEReadLocalSupportedFeaturesCommand<S, OkState>

fn check_ok( self, ) -> Result<<LEReadLocalSupportedFeaturesCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEReadLocalSupportedFeaturesCommand<S>

where S: Storage,

type Ok = LEReadLocalSupportedFeaturesCommand<S, OkState>

fn check_ok( self, ) -> Result<<LEReadLocalSupportedFeaturesCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEReadLocalSupportedFeaturesCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = LEReadLocalSupportedFeaturesCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEReadLocalSupportedFeaturesCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEReadLocalSupportedFeaturesCommandWriter<S, OkState>

where S: MutStorage,

type Ok = LEReadLocalSupportedFeaturesCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEReadLocalSupportedFeaturesCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEReadLocalSupportedFeaturesCommandWriter<S>

where S: MutStorage,

type Ok = LEReadLocalSupportedFeaturesCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEReadLocalSupportedFeaturesCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEReadMaxAdvertisingDataLengthCommand<S, CompleteState>

where S: Storage,

type Ok = LEReadMaxAdvertisingDataLengthCommand<S, OkState>

fn check_ok( self, ) -> Result<<LEReadMaxAdvertisingDataLengthCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEReadMaxAdvertisingDataLengthCommand<S, OkState>

where S: Storage,

type Ok = LEReadMaxAdvertisingDataLengthCommand<S, OkState>

fn check_ok( self, ) -> Result<<LEReadMaxAdvertisingDataLengthCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEReadMaxAdvertisingDataLengthCommand<S>

where S: Storage,

type Ok = LEReadMaxAdvertisingDataLengthCommand<S, OkState>

fn check_ok( self, ) -> Result<<LEReadMaxAdvertisingDataLengthCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEReadMaxAdvertisingDataLengthCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = LEReadMaxAdvertisingDataLengthCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEReadMaxAdvertisingDataLengthCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEReadMaxAdvertisingDataLengthCommandWriter<S, OkState>

where S: MutStorage,

type Ok = LEReadMaxAdvertisingDataLengthCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEReadMaxAdvertisingDataLengthCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEReadMaxAdvertisingDataLengthCommandWriter<S>

where S: MutStorage,

type Ok = LEReadMaxAdvertisingDataLengthCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEReadMaxAdvertisingDataLengthCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEReadNumSupportedAdvertisingSetsCommand<S, CompleteState>

where S: Storage,

type Ok = LEReadNumSupportedAdvertisingSetsCommand<S, OkState>

fn check_ok( self, ) -> Result<<LEReadNumSupportedAdvertisingSetsCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEReadNumSupportedAdvertisingSetsCommand<S, OkState>

where S: Storage,

type Ok = LEReadNumSupportedAdvertisingSetsCommand<S, OkState>

fn check_ok( self, ) -> Result<<LEReadNumSupportedAdvertisingSetsCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEReadNumSupportedAdvertisingSetsCommand<S>

where S: Storage,

type Ok = LEReadNumSupportedAdvertisingSetsCommand<S, OkState>

fn check_ok( self, ) -> Result<<LEReadNumSupportedAdvertisingSetsCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEReadNumSupportedAdvertisingSetsCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = LEReadNumSupportedAdvertisingSetsCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEReadNumSupportedAdvertisingSetsCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEReadNumSupportedAdvertisingSetsCommandWriter<S, OkState>

where S: MutStorage,

type Ok = LEReadNumSupportedAdvertisingSetsCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEReadNumSupportedAdvertisingSetsCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEReadNumSupportedAdvertisingSetsCommandWriter<S>

where S: MutStorage,

type Ok = LEReadNumSupportedAdvertisingSetsCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEReadNumSupportedAdvertisingSetsCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEReadRFPathCompensationCommand<S, CompleteState>

where S: Storage,

type Ok = LEReadRFPathCompensationCommand<S, OkState>

fn check_ok( self, ) -> Result<<LEReadRFPathCompensationCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEReadRFPathCompensationCommand<S, OkState>

where S: Storage,

type Ok = LEReadRFPathCompensationCommand<S, OkState>

fn check_ok( self, ) -> Result<<LEReadRFPathCompensationCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEReadRFPathCompensationCommand<S>

where S: Storage,

type Ok = LEReadRFPathCompensationCommand<S, OkState>

fn check_ok( self, ) -> Result<<LEReadRFPathCompensationCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEReadRFPathCompensationCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = LEReadRFPathCompensationCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEReadRFPathCompensationCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEReadRFPathCompensationCommandWriter<S, OkState>

where S: MutStorage,

type Ok = LEReadRFPathCompensationCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEReadRFPathCompensationCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEReadRFPathCompensationCommandWriter<S>

where S: MutStorage,

type Ok = LEReadRFPathCompensationCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEReadRFPathCompensationCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEReadRemoteFeaturesCommand<S, CompleteState>

where S: Storage,

type Ok = LEReadRemoteFeaturesCommand<S, OkState>

fn check_ok( self, ) -> Result<<LEReadRemoteFeaturesCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEReadRemoteFeaturesCommand<S, OkState>

where S: Storage,

type Ok = LEReadRemoteFeaturesCommand<S, OkState>

fn check_ok( self, ) -> Result<<LEReadRemoteFeaturesCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEReadRemoteFeaturesCommand<S>

where S: Storage,

type Ok = LEReadRemoteFeaturesCommand<S, OkState>

fn check_ok( self, ) -> Result<<LEReadRemoteFeaturesCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEReadRemoteFeaturesCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = LEReadRemoteFeaturesCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEReadRemoteFeaturesCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEReadRemoteFeaturesCommandWriter<S, OkState>

where S: MutStorage,

type Ok = LEReadRemoteFeaturesCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEReadRemoteFeaturesCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEReadRemoteFeaturesCommandWriter<S>

where S: MutStorage,

type Ok = LEReadRemoteFeaturesCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEReadRemoteFeaturesCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEReadSupportedStatesCommand<S, CompleteState>

where S: Storage,

type Ok = LEReadSupportedStatesCommand<S, OkState>

fn check_ok( self, ) -> Result<<LEReadSupportedStatesCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEReadSupportedStatesCommand<S, OkState>

where S: Storage,

type Ok = LEReadSupportedStatesCommand<S, OkState>

fn check_ok( self, ) -> Result<<LEReadSupportedStatesCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEReadSupportedStatesCommand<S>

where S: Storage,

type Ok = LEReadSupportedStatesCommand<S, OkState>

fn check_ok( self, ) -> Result<<LEReadSupportedStatesCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEReadSupportedStatesCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = LEReadSupportedStatesCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEReadSupportedStatesCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEReadSupportedStatesCommandWriter<S, OkState>

where S: MutStorage,

type Ok = LEReadSupportedStatesCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEReadSupportedStatesCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEReadSupportedStatesCommandWriter<S>

where S: MutStorage,

type Ok = LEReadSupportedStatesCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEReadSupportedStatesCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEReadTransmitPowerCommand<S, CompleteState>

where S: Storage,

type Ok = LEReadTransmitPowerCommand<S, OkState>

fn check_ok( self, ) -> Result<<LEReadTransmitPowerCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEReadTransmitPowerCommand<S, OkState>

where S: Storage,

type Ok = LEReadTransmitPowerCommand<S, OkState>

fn check_ok( self, ) -> Result<<LEReadTransmitPowerCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEReadTransmitPowerCommand<S>

where S: Storage,

type Ok = LEReadTransmitPowerCommand<S, OkState>

fn check_ok( self, ) -> Result<<LEReadTransmitPowerCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEReadTransmitPowerCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = LEReadTransmitPowerCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEReadTransmitPowerCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEReadTransmitPowerCommandWriter<S, OkState>

where S: MutStorage,

type Ok = LEReadTransmitPowerCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEReadTransmitPowerCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEReadTransmitPowerCommandWriter<S>

where S: MutStorage,

type Ok = LEReadTransmitPowerCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEReadTransmitPowerCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LERejectCISRequestCommand<S, CompleteState>

where S: Storage,

type Ok = LERejectCISRequestCommand<S, OkState>

fn check_ok( self, ) -> Result<<LERejectCISRequestCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LERejectCISRequestCommand<S, OkState>

where S: Storage,

type Ok = LERejectCISRequestCommand<S, OkState>

fn check_ok( self, ) -> Result<<LERejectCISRequestCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LERejectCISRequestCommand<S>

where S: Storage,

type Ok = LERejectCISRequestCommand<S, OkState>

fn check_ok( self, ) -> Result<<LERejectCISRequestCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LERejectCISRequestCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = LERejectCISRequestCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LERejectCISRequestCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LERejectCISRequestCommandWriter<S, OkState>

where S: MutStorage,

type Ok = LERejectCISRequestCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LERejectCISRequestCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LERejectCISRequestCommandWriter<S>

where S: MutStorage,

type Ok = LERejectCISRequestCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LERejectCISRequestCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LERemoveAdvertisingSetCommand<S, CompleteState>

where S: Storage,

type Ok = LERemoveAdvertisingSetCommand<S, OkState>

fn check_ok( self, ) -> Result<<LERemoveAdvertisingSetCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LERemoveAdvertisingSetCommand<S, OkState>

where S: Storage,

type Ok = LERemoveAdvertisingSetCommand<S, OkState>

fn check_ok( self, ) -> Result<<LERemoveAdvertisingSetCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LERemoveAdvertisingSetCommand<S>

where S: Storage,

type Ok = LERemoveAdvertisingSetCommand<S, OkState>

fn check_ok( self, ) -> Result<<LERemoveAdvertisingSetCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LERemoveAdvertisingSetCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = LERemoveAdvertisingSetCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LERemoveAdvertisingSetCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LERemoveAdvertisingSetCommandWriter<S, OkState>

where S: MutStorage,

type Ok = LERemoveAdvertisingSetCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LERemoveAdvertisingSetCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LERemoveAdvertisingSetCommandWriter<S>

where S: MutStorage,

type Ok = LERemoveAdvertisingSetCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LERemoveAdvertisingSetCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LERemoveCIGCommand<S, CompleteState>

where S: Storage,

type Ok = LERemoveCIGCommand<S, OkState>

fn check_ok( self, ) -> Result<<LERemoveCIGCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LERemoveCIGCommand<S, OkState>

where S: Storage,

type Ok = LERemoveCIGCommand<S, OkState>

fn check_ok( self, ) -> Result<<LERemoveCIGCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LERemoveCIGCommand<S>

where S: Storage,

type Ok = LERemoveCIGCommand<S, OkState>

fn check_ok(self) -> Result<<LERemoveCIGCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LERemoveCIGCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = LERemoveCIGCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LERemoveCIGCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LERemoveCIGCommandWriter<S, OkState>

where S: MutStorage,

type Ok = LERemoveCIGCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LERemoveCIGCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LERemoveCIGCommandWriter<S>

where S: MutStorage,

type Ok = LERemoveCIGCommandWriter<S, OkState>

fn check_ok(self) -> Result<<LERemoveCIGCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LERemoveDeviceFromFilterAcceptListCommand<S, CompleteState>

where S: Storage,

type Ok = LERemoveDeviceFromFilterAcceptListCommand<S, OkState>

fn check_ok( self, ) -> Result<<LERemoveDeviceFromFilterAcceptListCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LERemoveDeviceFromFilterAcceptListCommand<S, OkState>

where S: Storage,

type Ok = LERemoveDeviceFromFilterAcceptListCommand<S, OkState>

fn check_ok( self, ) -> Result<<LERemoveDeviceFromFilterAcceptListCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LERemoveDeviceFromFilterAcceptListCommand<S>

where S: Storage,

type Ok = LERemoveDeviceFromFilterAcceptListCommand<S, OkState>

fn check_ok( self, ) -> Result<<LERemoveDeviceFromFilterAcceptListCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LERemoveDeviceFromFilterAcceptListCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = LERemoveDeviceFromFilterAcceptListCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LERemoveDeviceFromFilterAcceptListCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LERemoveDeviceFromFilterAcceptListCommandWriter<S, OkState>

where S: MutStorage,

type Ok = LERemoveDeviceFromFilterAcceptListCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LERemoveDeviceFromFilterAcceptListCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LERemoveDeviceFromFilterAcceptListCommandWriter<S>

where S: MutStorage,

type Ok = LERemoveDeviceFromFilterAcceptListCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LERemoveDeviceFromFilterAcceptListCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LERemoveDeviceFromPeriodicAdvertiserListCommand<S, CompleteState>

where S: Storage,

type Ok = LERemoveDeviceFromPeriodicAdvertiserListCommand<S, OkState>

fn check_ok( self, ) -> Result<<LERemoveDeviceFromPeriodicAdvertiserListCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LERemoveDeviceFromPeriodicAdvertiserListCommand<S, OkState>

where S: Storage,

type Ok = LERemoveDeviceFromPeriodicAdvertiserListCommand<S, OkState>

fn check_ok( self, ) -> Result<<LERemoveDeviceFromPeriodicAdvertiserListCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LERemoveDeviceFromPeriodicAdvertiserListCommand<S>

where S: Storage,

type Ok = LERemoveDeviceFromPeriodicAdvertiserListCommand<S, OkState>

fn check_ok( self, ) -> Result<<LERemoveDeviceFromPeriodicAdvertiserListCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LERemoveDeviceFromPeriodicAdvertiserListCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = LERemoveDeviceFromPeriodicAdvertiserListCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LERemoveDeviceFromPeriodicAdvertiserListCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LERemoveDeviceFromPeriodicAdvertiserListCommandWriter<S, OkState>

where S: MutStorage,

type Ok = LERemoveDeviceFromPeriodicAdvertiserListCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LERemoveDeviceFromPeriodicAdvertiserListCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LERemoveDeviceFromPeriodicAdvertiserListCommandWriter<S>

where S: MutStorage,

type Ok = LERemoveDeviceFromPeriodicAdvertiserListCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LERemoveDeviceFromPeriodicAdvertiserListCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LERemoveISODataPathCommand<S, CompleteState>

where S: Storage,

type Ok = LERemoveISODataPathCommand<S, OkState>

fn check_ok( self, ) -> Result<<LERemoveISODataPathCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LERemoveISODataPathCommand<S, OkState>

where S: Storage,

type Ok = LERemoveISODataPathCommand<S, OkState>

fn check_ok( self, ) -> Result<<LERemoveISODataPathCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LERemoveISODataPathCommand<S>

where S: Storage,

type Ok = LERemoveISODataPathCommand<S, OkState>

fn check_ok( self, ) -> Result<<LERemoveISODataPathCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LERemoveISODataPathCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = LERemoveISODataPathCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LERemoveISODataPathCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LERemoveISODataPathCommandWriter<S, OkState>

where S: MutStorage,

type Ok = LERemoveISODataPathCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LERemoveISODataPathCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LERemoveISODataPathCommandWriter<S>

where S: MutStorage,

type Ok = LERemoveISODataPathCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LERemoveISODataPathCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LERemoveISODataPathCommand_EmbossReservedAnonymousField1<S, CompleteState>

where S: Storage,

type Ok = LERemoveISODataPathCommand_EmbossReservedAnonymousField1<S, OkState>

fn check_ok( self, ) -> Result<<LERemoveISODataPathCommand_EmbossReservedAnonymousField1<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LERemoveISODataPathCommand_EmbossReservedAnonymousField1<S, OkState>

where S: Storage,

type Ok = LERemoveISODataPathCommand_EmbossReservedAnonymousField1<S, OkState>

fn check_ok( self, ) -> Result<<LERemoveISODataPathCommand_EmbossReservedAnonymousField1<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LERemoveISODataPathCommand_EmbossReservedAnonymousField1<S>

where S: Storage,

type Ok = LERemoveISODataPathCommand_EmbossReservedAnonymousField1<S, OkState>

fn check_ok( self, ) -> Result<<LERemoveISODataPathCommand_EmbossReservedAnonymousField1<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LERemoveISODataPathCommand_EmbossReservedAnonymousField1Writer<S, CompleteState>

where S: MutStorage,

type Ok = LERemoveISODataPathCommand_EmbossReservedAnonymousField1Writer<S, OkState>

fn check_ok( self, ) -> Result<<LERemoveISODataPathCommand_EmbossReservedAnonymousField1Writer<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LERemoveISODataPathCommand_EmbossReservedAnonymousField1Writer<S, OkState>

where S: MutStorage,

type Ok = LERemoveISODataPathCommand_EmbossReservedAnonymousField1Writer<S, OkState>

fn check_ok( self, ) -> Result<<LERemoveISODataPathCommand_EmbossReservedAnonymousField1Writer<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LERemoveISODataPathCommand_EmbossReservedAnonymousField1Writer<S>

where S: MutStorage,

type Ok = LERemoveISODataPathCommand_EmbossReservedAnonymousField1Writer<S, OkState>

fn check_ok( self, ) -> Result<<LERemoveISODataPathCommand_EmbossReservedAnonymousField1Writer<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LERequestPeerSCACommand<S, CompleteState>

where S: Storage,

type Ok = LERequestPeerSCACommand<S, OkState>

fn check_ok( self, ) -> Result<<LERequestPeerSCACommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LERequestPeerSCACommand<S, OkState>

where S: Storage,

type Ok = LERequestPeerSCACommand<S, OkState>

fn check_ok( self, ) -> Result<<LERequestPeerSCACommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LERequestPeerSCACommand<S>

where S: Storage,

type Ok = LERequestPeerSCACommand<S, OkState>

fn check_ok(self) -> Result<<LERequestPeerSCACommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LERequestPeerSCACommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = LERequestPeerSCACommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LERequestPeerSCACommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LERequestPeerSCACommandWriter<S, OkState>

where S: MutStorage,

type Ok = LERequestPeerSCACommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LERequestPeerSCACommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LERequestPeerSCACommandWriter<S>

where S: MutStorage,

type Ok = LERequestPeerSCACommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LERequestPeerSCACommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEScanPHYBits<S, CompleteState>

where S: Storage,

type Ok = LEScanPHYBits<S, OkState>

fn check_ok( self, ) -> Result<<LEScanPHYBits<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEScanPHYBits<S, OkState>

where S: Storage,

type Ok = LEScanPHYBits<S, OkState>

fn check_ok(self) -> Result<<LEScanPHYBits<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEScanPHYBits<S>

where S: Storage,

type Ok = LEScanPHYBits<S, OkState>

fn check_ok(self) -> Result<<LEScanPHYBits<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEScanPHYBitsWriter<S, CompleteState>

where S: MutStorage,

type Ok = LEScanPHYBitsWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEScanPHYBitsWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEScanPHYBitsWriter<S, OkState>

where S: MutStorage,

type Ok = LEScanPHYBitsWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEScanPHYBitsWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEScanPHYBitsWriter<S>

where S: MutStorage,

type Ok = LEScanPHYBitsWriter<S, OkState>

fn check_ok(self) -> Result<<LEScanPHYBitsWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetAddressResolutionEnableCommand<S, CompleteState>

where S: Storage,

type Ok = LESetAddressResolutionEnableCommand<S, OkState>

fn check_ok( self, ) -> Result<<LESetAddressResolutionEnableCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetAddressResolutionEnableCommand<S, OkState>

where S: Storage,

type Ok = LESetAddressResolutionEnableCommand<S, OkState>

fn check_ok( self, ) -> Result<<LESetAddressResolutionEnableCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetAddressResolutionEnableCommand<S>

where S: Storage,

type Ok = LESetAddressResolutionEnableCommand<S, OkState>

fn check_ok( self, ) -> Result<<LESetAddressResolutionEnableCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetAddressResolutionEnableCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = LESetAddressResolutionEnableCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetAddressResolutionEnableCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetAddressResolutionEnableCommandWriter<S, OkState>

where S: MutStorage,

type Ok = LESetAddressResolutionEnableCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetAddressResolutionEnableCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetAddressResolutionEnableCommandWriter<S>

where S: MutStorage,

type Ok = LESetAddressResolutionEnableCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetAddressResolutionEnableCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetAdvertisingDataCommand<S, CompleteState>

where S: Storage,

type Ok = LESetAdvertisingDataCommand<S, OkState>

fn check_ok( self, ) -> Result<<LESetAdvertisingDataCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetAdvertisingDataCommand<S, OkState>

where S: Storage,

type Ok = LESetAdvertisingDataCommand<S, OkState>

fn check_ok( self, ) -> Result<<LESetAdvertisingDataCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetAdvertisingDataCommand<S>

where S: Storage,

type Ok = LESetAdvertisingDataCommand<S, OkState>

fn check_ok( self, ) -> Result<<LESetAdvertisingDataCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetAdvertisingDataCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = LESetAdvertisingDataCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetAdvertisingDataCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetAdvertisingDataCommandWriter<S, OkState>

where S: MutStorage,

type Ok = LESetAdvertisingDataCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetAdvertisingDataCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetAdvertisingDataCommandWriter<S>

where S: MutStorage,

type Ok = LESetAdvertisingDataCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetAdvertisingDataCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetAdvertisingEnableCommand<S, CompleteState>

where S: Storage,

type Ok = LESetAdvertisingEnableCommand<S, OkState>

fn check_ok( self, ) -> Result<<LESetAdvertisingEnableCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetAdvertisingEnableCommand<S, OkState>

where S: Storage,

type Ok = LESetAdvertisingEnableCommand<S, OkState>

fn check_ok( self, ) -> Result<<LESetAdvertisingEnableCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetAdvertisingEnableCommand<S>

where S: Storage,

type Ok = LESetAdvertisingEnableCommand<S, OkState>

fn check_ok( self, ) -> Result<<LESetAdvertisingEnableCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetAdvertisingEnableCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = LESetAdvertisingEnableCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetAdvertisingEnableCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetAdvertisingEnableCommandWriter<S, OkState>

where S: MutStorage,

type Ok = LESetAdvertisingEnableCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetAdvertisingEnableCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetAdvertisingEnableCommandWriter<S>

where S: MutStorage,

type Ok = LESetAdvertisingEnableCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetAdvertisingEnableCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetAdvertisingParametersCommand<S, CompleteState>

where S: Storage,

type Ok = LESetAdvertisingParametersCommand<S, OkState>

fn check_ok( self, ) -> Result<<LESetAdvertisingParametersCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetAdvertisingParametersCommand<S, OkState>

where S: Storage,

type Ok = LESetAdvertisingParametersCommand<S, OkState>

fn check_ok( self, ) -> Result<<LESetAdvertisingParametersCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetAdvertisingParametersCommand<S>

where S: Storage,

type Ok = LESetAdvertisingParametersCommand<S, OkState>

fn check_ok( self, ) -> Result<<LESetAdvertisingParametersCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetAdvertisingParametersCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = LESetAdvertisingParametersCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetAdvertisingParametersCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetAdvertisingParametersCommandWriter<S, OkState>

where S: MutStorage,

type Ok = LESetAdvertisingParametersCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetAdvertisingParametersCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetAdvertisingParametersCommandWriter<S>

where S: MutStorage,

type Ok = LESetAdvertisingParametersCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetAdvertisingParametersCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetAdvertisingParametersCommand_EmbossReservedAnonymousField9<S, CompleteState>

where S: Storage,

type Ok = LESetAdvertisingParametersCommand_EmbossReservedAnonymousField9<S, OkState>

fn check_ok( self, ) -> Result<<LESetAdvertisingParametersCommand_EmbossReservedAnonymousField9<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetAdvertisingParametersCommand_EmbossReservedAnonymousField9<S, OkState>

where S: Storage,

type Ok = LESetAdvertisingParametersCommand_EmbossReservedAnonymousField9<S, OkState>

fn check_ok( self, ) -> Result<<LESetAdvertisingParametersCommand_EmbossReservedAnonymousField9<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetAdvertisingParametersCommand_EmbossReservedAnonymousField9<S>

where S: Storage,

type Ok = LESetAdvertisingParametersCommand_EmbossReservedAnonymousField9<S, OkState>

fn check_ok( self, ) -> Result<<LESetAdvertisingParametersCommand_EmbossReservedAnonymousField9<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetAdvertisingParametersCommand_EmbossReservedAnonymousField9Writer<S, CompleteState>

where S: MutStorage,

type Ok = LESetAdvertisingParametersCommand_EmbossReservedAnonymousField9Writer<S, OkState>

fn check_ok( self, ) -> Result<<LESetAdvertisingParametersCommand_EmbossReservedAnonymousField9Writer<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetAdvertisingParametersCommand_EmbossReservedAnonymousField9Writer<S, OkState>

where S: MutStorage,

type Ok = LESetAdvertisingParametersCommand_EmbossReservedAnonymousField9Writer<S, OkState>

fn check_ok( self, ) -> Result<<LESetAdvertisingParametersCommand_EmbossReservedAnonymousField9Writer<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetAdvertisingParametersCommand_EmbossReservedAnonymousField9Writer<S>

where S: MutStorage,

type Ok = LESetAdvertisingParametersCommand_EmbossReservedAnonymousField9Writer<S, OkState>

fn check_ok( self, ) -> Result<<LESetAdvertisingParametersCommand_EmbossReservedAnonymousField9Writer<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetAdvertisingSetRandomAddressCommand<S, CompleteState>

where S: Storage,

type Ok = LESetAdvertisingSetRandomAddressCommand<S, OkState>

fn check_ok( self, ) -> Result<<LESetAdvertisingSetRandomAddressCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetAdvertisingSetRandomAddressCommand<S, OkState>

where S: Storage,

type Ok = LESetAdvertisingSetRandomAddressCommand<S, OkState>

fn check_ok( self, ) -> Result<<LESetAdvertisingSetRandomAddressCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetAdvertisingSetRandomAddressCommand<S>

where S: Storage,

type Ok = LESetAdvertisingSetRandomAddressCommand<S, OkState>

fn check_ok( self, ) -> Result<<LESetAdvertisingSetRandomAddressCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetAdvertisingSetRandomAddressCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = LESetAdvertisingSetRandomAddressCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetAdvertisingSetRandomAddressCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetAdvertisingSetRandomAddressCommandWriter<S, OkState>

where S: MutStorage,

type Ok = LESetAdvertisingSetRandomAddressCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetAdvertisingSetRandomAddressCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetAdvertisingSetRandomAddressCommandWriter<S>

where S: MutStorage,

type Ok = LESetAdvertisingSetRandomAddressCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetAdvertisingSetRandomAddressCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetCIGParametersCISOptions<S, CompleteState>

where S: Storage,

type Ok = LESetCIGParametersCISOptions<S, OkState>

fn check_ok( self, ) -> Result<<LESetCIGParametersCISOptions<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetCIGParametersCISOptions<S, OkState>

where S: Storage,

type Ok = LESetCIGParametersCISOptions<S, OkState>

fn check_ok( self, ) -> Result<<LESetCIGParametersCISOptions<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetCIGParametersCISOptions<S>

where S: Storage,

type Ok = LESetCIGParametersCISOptions<S, OkState>

fn check_ok( self, ) -> Result<<LESetCIGParametersCISOptions<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetCIGParametersCISOptionsWriter<S, CompleteState>

where S: MutStorage,

type Ok = LESetCIGParametersCISOptionsWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetCIGParametersCISOptionsWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetCIGParametersCISOptionsWriter<S, OkState>

where S: MutStorage,

type Ok = LESetCIGParametersCISOptionsWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetCIGParametersCISOptionsWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetCIGParametersCISOptionsWriter<S>

where S: MutStorage,

type Ok = LESetCIGParametersCISOptionsWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetCIGParametersCISOptionsWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetCIGParametersCISOptions_EmbossReservedAnonymousField16<S, CompleteState>

where S: Storage,

type Ok = LESetCIGParametersCISOptions_EmbossReservedAnonymousField16<S, OkState>

fn check_ok( self, ) -> Result<<LESetCIGParametersCISOptions_EmbossReservedAnonymousField16<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetCIGParametersCISOptions_EmbossReservedAnonymousField16<S, OkState>

where S: Storage,

type Ok = LESetCIGParametersCISOptions_EmbossReservedAnonymousField16<S, OkState>

fn check_ok( self, ) -> Result<<LESetCIGParametersCISOptions_EmbossReservedAnonymousField16<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetCIGParametersCISOptions_EmbossReservedAnonymousField16<S>

where S: Storage,

type Ok = LESetCIGParametersCISOptions_EmbossReservedAnonymousField16<S, OkState>

fn check_ok( self, ) -> Result<<LESetCIGParametersCISOptions_EmbossReservedAnonymousField16<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetCIGParametersCISOptions_EmbossReservedAnonymousField16Writer<S, CompleteState>

where S: MutStorage,

type Ok = LESetCIGParametersCISOptions_EmbossReservedAnonymousField16Writer<S, OkState>

fn check_ok( self, ) -> Result<<LESetCIGParametersCISOptions_EmbossReservedAnonymousField16Writer<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetCIGParametersCISOptions_EmbossReservedAnonymousField16Writer<S, OkState>

where S: MutStorage,

type Ok = LESetCIGParametersCISOptions_EmbossReservedAnonymousField16Writer<S, OkState>

fn check_ok( self, ) -> Result<<LESetCIGParametersCISOptions_EmbossReservedAnonymousField16Writer<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetCIGParametersCISOptions_EmbossReservedAnonymousField16Writer<S>

where S: MutStorage,

type Ok = LESetCIGParametersCISOptions_EmbossReservedAnonymousField16Writer<S, OkState>

fn check_ok( self, ) -> Result<<LESetCIGParametersCISOptions_EmbossReservedAnonymousField16Writer<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetCIGParametersCISOptions_EmbossReservedAnonymousField17<S, CompleteState>

where S: Storage,

type Ok = LESetCIGParametersCISOptions_EmbossReservedAnonymousField17<S, OkState>

fn check_ok( self, ) -> Result<<LESetCIGParametersCISOptions_EmbossReservedAnonymousField17<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetCIGParametersCISOptions_EmbossReservedAnonymousField17<S, OkState>

where S: Storage,

type Ok = LESetCIGParametersCISOptions_EmbossReservedAnonymousField17<S, OkState>

fn check_ok( self, ) -> Result<<LESetCIGParametersCISOptions_EmbossReservedAnonymousField17<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetCIGParametersCISOptions_EmbossReservedAnonymousField17<S>

where S: Storage,

type Ok = LESetCIGParametersCISOptions_EmbossReservedAnonymousField17<S, OkState>

fn check_ok( self, ) -> Result<<LESetCIGParametersCISOptions_EmbossReservedAnonymousField17<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetCIGParametersCISOptions_EmbossReservedAnonymousField17Writer<S, CompleteState>

where S: MutStorage,

type Ok = LESetCIGParametersCISOptions_EmbossReservedAnonymousField17Writer<S, OkState>

fn check_ok( self, ) -> Result<<LESetCIGParametersCISOptions_EmbossReservedAnonymousField17Writer<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetCIGParametersCISOptions_EmbossReservedAnonymousField17Writer<S, OkState>

where S: MutStorage,

type Ok = LESetCIGParametersCISOptions_EmbossReservedAnonymousField17Writer<S, OkState>

fn check_ok( self, ) -> Result<<LESetCIGParametersCISOptions_EmbossReservedAnonymousField17Writer<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetCIGParametersCISOptions_EmbossReservedAnonymousField17Writer<S>

where S: MutStorage,

type Ok = LESetCIGParametersCISOptions_EmbossReservedAnonymousField17Writer<S, OkState>

fn check_ok( self, ) -> Result<<LESetCIGParametersCISOptions_EmbossReservedAnonymousField17Writer<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetCIGParametersCommand<S, CompleteState>

where S: Storage,

type Ok = LESetCIGParametersCommand<S, OkState>

fn check_ok( self, ) -> Result<<LESetCIGParametersCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetCIGParametersCommand<S, OkState>

where S: Storage,

type Ok = LESetCIGParametersCommand<S, OkState>

fn check_ok( self, ) -> Result<<LESetCIGParametersCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetCIGParametersCommand<S>

where S: Storage,

type Ok = LESetCIGParametersCommand<S, OkState>

fn check_ok( self, ) -> Result<<LESetCIGParametersCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetCIGParametersCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = LESetCIGParametersCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetCIGParametersCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetCIGParametersCommandWriter<S, OkState>

where S: MutStorage,

type Ok = LESetCIGParametersCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetCIGParametersCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetCIGParametersCommandWriter<S>

where S: MutStorage,

type Ok = LESetCIGParametersCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetCIGParametersCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetEventMaskCommand<S, CompleteState>

where S: Storage,

type Ok = LESetEventMaskCommand<S, OkState>

fn check_ok( self, ) -> Result<<LESetEventMaskCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetEventMaskCommand<S, OkState>

where S: Storage,

type Ok = LESetEventMaskCommand<S, OkState>

fn check_ok( self, ) -> Result<<LESetEventMaskCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetEventMaskCommand<S>

where S: Storage,

type Ok = LESetEventMaskCommand<S, OkState>

fn check_ok(self) -> Result<<LESetEventMaskCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetEventMaskCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = LESetEventMaskCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetEventMaskCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetEventMaskCommandWriter<S, OkState>

where S: MutStorage,

type Ok = LESetEventMaskCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetEventMaskCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetEventMaskCommandWriter<S>

where S: MutStorage,

type Ok = LESetEventMaskCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetEventMaskCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetEventMaskCommand_EmbossReservedAnonymousField10<S, CompleteState>

where S: Storage,

type Ok = LESetEventMaskCommand_EmbossReservedAnonymousField10<S, OkState>

fn check_ok( self, ) -> Result<<LESetEventMaskCommand_EmbossReservedAnonymousField10<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetEventMaskCommand_EmbossReservedAnonymousField10<S, OkState>

where S: Storage,

type Ok = LESetEventMaskCommand_EmbossReservedAnonymousField10<S, OkState>

fn check_ok( self, ) -> Result<<LESetEventMaskCommand_EmbossReservedAnonymousField10<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetEventMaskCommand_EmbossReservedAnonymousField10<S>

where S: Storage,

type Ok = LESetEventMaskCommand_EmbossReservedAnonymousField10<S, OkState>

fn check_ok( self, ) -> Result<<LESetEventMaskCommand_EmbossReservedAnonymousField10<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetEventMaskCommand_EmbossReservedAnonymousField10Writer<S, CompleteState>

where S: MutStorage,

type Ok = LESetEventMaskCommand_EmbossReservedAnonymousField10Writer<S, OkState>

fn check_ok( self, ) -> Result<<LESetEventMaskCommand_EmbossReservedAnonymousField10Writer<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetEventMaskCommand_EmbossReservedAnonymousField10Writer<S, OkState>

where S: MutStorage,

type Ok = LESetEventMaskCommand_EmbossReservedAnonymousField10Writer<S, OkState>

fn check_ok( self, ) -> Result<<LESetEventMaskCommand_EmbossReservedAnonymousField10Writer<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetEventMaskCommand_EmbossReservedAnonymousField10Writer<S>

where S: MutStorage,

type Ok = LESetEventMaskCommand_EmbossReservedAnonymousField10Writer<S, OkState>

fn check_ok( self, ) -> Result<<LESetEventMaskCommand_EmbossReservedAnonymousField10Writer<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetExtendedAdvertisingDataCommand<S, CompleteState>

where S: Storage,

type Ok = LESetExtendedAdvertisingDataCommand<S, OkState>

fn check_ok( self, ) -> Result<<LESetExtendedAdvertisingDataCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetExtendedAdvertisingDataCommand<S, OkState>

where S: Storage,

type Ok = LESetExtendedAdvertisingDataCommand<S, OkState>

fn check_ok( self, ) -> Result<<LESetExtendedAdvertisingDataCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetExtendedAdvertisingDataCommand<S>

where S: Storage,

type Ok = LESetExtendedAdvertisingDataCommand<S, OkState>

fn check_ok( self, ) -> Result<<LESetExtendedAdvertisingDataCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetExtendedAdvertisingDataCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = LESetExtendedAdvertisingDataCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetExtendedAdvertisingDataCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetExtendedAdvertisingDataCommandWriter<S, OkState>

where S: MutStorage,

type Ok = LESetExtendedAdvertisingDataCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetExtendedAdvertisingDataCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetExtendedAdvertisingDataCommandWriter<S>

where S: MutStorage,

type Ok = LESetExtendedAdvertisingDataCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetExtendedAdvertisingDataCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetExtendedAdvertisingEnableCommand<S, CompleteState>

where S: Storage,

type Ok = LESetExtendedAdvertisingEnableCommand<S, OkState>

fn check_ok( self, ) -> Result<<LESetExtendedAdvertisingEnableCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetExtendedAdvertisingEnableCommand<S, OkState>

where S: Storage,

type Ok = LESetExtendedAdvertisingEnableCommand<S, OkState>

fn check_ok( self, ) -> Result<<LESetExtendedAdvertisingEnableCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetExtendedAdvertisingEnableCommand<S>

where S: Storage,

type Ok = LESetExtendedAdvertisingEnableCommand<S, OkState>

fn check_ok( self, ) -> Result<<LESetExtendedAdvertisingEnableCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetExtendedAdvertisingEnableCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = LESetExtendedAdvertisingEnableCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetExtendedAdvertisingEnableCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetExtendedAdvertisingEnableCommandWriter<S, OkState>

where S: MutStorage,

type Ok = LESetExtendedAdvertisingEnableCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetExtendedAdvertisingEnableCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetExtendedAdvertisingEnableCommandWriter<S>

where S: MutStorage,

type Ok = LESetExtendedAdvertisingEnableCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetExtendedAdvertisingEnableCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetExtendedAdvertisingEnableData<S, CompleteState>

where S: Storage,

type Ok = LESetExtendedAdvertisingEnableData<S, OkState>

fn check_ok( self, ) -> Result<<LESetExtendedAdvertisingEnableData<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetExtendedAdvertisingEnableData<S, OkState>

where S: Storage,

type Ok = LESetExtendedAdvertisingEnableData<S, OkState>

fn check_ok( self, ) -> Result<<LESetExtendedAdvertisingEnableData<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetExtendedAdvertisingEnableData<S>

where S: Storage,

type Ok = LESetExtendedAdvertisingEnableData<S, OkState>

fn check_ok( self, ) -> Result<<LESetExtendedAdvertisingEnableData<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetExtendedAdvertisingEnableDataWriter<S, CompleteState>

where S: MutStorage,

type Ok = LESetExtendedAdvertisingEnableDataWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetExtendedAdvertisingEnableDataWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetExtendedAdvertisingEnableDataWriter<S, OkState>

where S: MutStorage,

type Ok = LESetExtendedAdvertisingEnableDataWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetExtendedAdvertisingEnableDataWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetExtendedAdvertisingEnableDataWriter<S>

where S: MutStorage,

type Ok = LESetExtendedAdvertisingEnableDataWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetExtendedAdvertisingEnableDataWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetExtendedAdvertisingParametersV1Command<S, CompleteState>

where S: Storage,

type Ok = LESetExtendedAdvertisingParametersV1Command<S, OkState>

fn check_ok( self, ) -> Result<<LESetExtendedAdvertisingParametersV1Command<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetExtendedAdvertisingParametersV1Command<S, OkState>

where S: Storage,

type Ok = LESetExtendedAdvertisingParametersV1Command<S, OkState>

fn check_ok( self, ) -> Result<<LESetExtendedAdvertisingParametersV1Command<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetExtendedAdvertisingParametersV1Command<S>

where S: Storage,

type Ok = LESetExtendedAdvertisingParametersV1Command<S, OkState>

fn check_ok( self, ) -> Result<<LESetExtendedAdvertisingParametersV1Command<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetExtendedAdvertisingParametersV1CommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = LESetExtendedAdvertisingParametersV1CommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetExtendedAdvertisingParametersV1CommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetExtendedAdvertisingParametersV1CommandWriter<S, OkState>

where S: MutStorage,

type Ok = LESetExtendedAdvertisingParametersV1CommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetExtendedAdvertisingParametersV1CommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetExtendedAdvertisingParametersV1CommandWriter<S>

where S: MutStorage,

type Ok = LESetExtendedAdvertisingParametersV1CommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetExtendedAdvertisingParametersV1CommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetExtendedAdvertisingParametersV1Command_EmbossReservedAnonymousField8<S, CompleteState>

where S: Storage,

type Ok = LESetExtendedAdvertisingParametersV1Command_EmbossReservedAnonymousField8<S, OkState>

fn check_ok( self, ) -> Result<<LESetExtendedAdvertisingParametersV1Command_EmbossReservedAnonymousField8<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetExtendedAdvertisingParametersV1Command_EmbossReservedAnonymousField8<S, OkState>

where S: Storage,

type Ok = LESetExtendedAdvertisingParametersV1Command_EmbossReservedAnonymousField8<S, OkState>

fn check_ok( self, ) -> Result<<LESetExtendedAdvertisingParametersV1Command_EmbossReservedAnonymousField8<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetExtendedAdvertisingParametersV1Command_EmbossReservedAnonymousField8<S>

where S: Storage,

type Ok = LESetExtendedAdvertisingParametersV1Command_EmbossReservedAnonymousField8<S, OkState>

fn check_ok( self, ) -> Result<<LESetExtendedAdvertisingParametersV1Command_EmbossReservedAnonymousField8<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetExtendedAdvertisingParametersV1Command_EmbossReservedAnonymousField8Writer<S, CompleteState>

where S: MutStorage,

type Ok = LESetExtendedAdvertisingParametersV1Command_EmbossReservedAnonymousField8Writer<S, OkState>

fn check_ok( self, ) -> Result<<LESetExtendedAdvertisingParametersV1Command_EmbossReservedAnonymousField8Writer<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetExtendedAdvertisingParametersV1Command_EmbossReservedAnonymousField8Writer<S, OkState>

where S: MutStorage,

type Ok = LESetExtendedAdvertisingParametersV1Command_EmbossReservedAnonymousField8Writer<S, OkState>

fn check_ok( self, ) -> Result<<LESetExtendedAdvertisingParametersV1Command_EmbossReservedAnonymousField8Writer<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetExtendedAdvertisingParametersV1Command_EmbossReservedAnonymousField8Writer<S>

where S: MutStorage,

type Ok = LESetExtendedAdvertisingParametersV1Command_EmbossReservedAnonymousField8Writer<S, OkState>

fn check_ok( self, ) -> Result<<LESetExtendedAdvertisingParametersV1Command_EmbossReservedAnonymousField8Writer<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetExtendedScanEnableCommand<S, CompleteState>

where S: Storage,

type Ok = LESetExtendedScanEnableCommand<S, OkState>

fn check_ok( self, ) -> Result<<LESetExtendedScanEnableCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetExtendedScanEnableCommand<S, OkState>

where S: Storage,

type Ok = LESetExtendedScanEnableCommand<S, OkState>

fn check_ok( self, ) -> Result<<LESetExtendedScanEnableCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetExtendedScanEnableCommand<S>

where S: Storage,

type Ok = LESetExtendedScanEnableCommand<S, OkState>

fn check_ok( self, ) -> Result<<LESetExtendedScanEnableCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetExtendedScanEnableCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = LESetExtendedScanEnableCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetExtendedScanEnableCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetExtendedScanEnableCommandWriter<S, OkState>

where S: MutStorage,

type Ok = LESetExtendedScanEnableCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetExtendedScanEnableCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetExtendedScanEnableCommandWriter<S>

where S: MutStorage,

type Ok = LESetExtendedScanEnableCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetExtendedScanEnableCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetExtendedScanParametersCommand<S, CompleteState>

where S: Storage,

type Ok = LESetExtendedScanParametersCommand<S, OkState>

fn check_ok( self, ) -> Result<<LESetExtendedScanParametersCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetExtendedScanParametersCommand<S, OkState>

where S: Storage,

type Ok = LESetExtendedScanParametersCommand<S, OkState>

fn check_ok( self, ) -> Result<<LESetExtendedScanParametersCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetExtendedScanParametersCommand<S>

where S: Storage,

type Ok = LESetExtendedScanParametersCommand<S, OkState>

fn check_ok( self, ) -> Result<<LESetExtendedScanParametersCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetExtendedScanParametersCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = LESetExtendedScanParametersCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetExtendedScanParametersCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetExtendedScanParametersCommandWriter<S, OkState>

where S: MutStorage,

type Ok = LESetExtendedScanParametersCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetExtendedScanParametersCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetExtendedScanParametersCommandWriter<S>

where S: MutStorage,

type Ok = LESetExtendedScanParametersCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetExtendedScanParametersCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetExtendedScanParametersCommand_EmbossReservedAnonymousField7<S, CompleteState>

where S: Storage,

type Ok = LESetExtendedScanParametersCommand_EmbossReservedAnonymousField7<S, OkState>

fn check_ok( self, ) -> Result<<LESetExtendedScanParametersCommand_EmbossReservedAnonymousField7<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetExtendedScanParametersCommand_EmbossReservedAnonymousField7<S, OkState>

where S: Storage,

type Ok = LESetExtendedScanParametersCommand_EmbossReservedAnonymousField7<S, OkState>

fn check_ok( self, ) -> Result<<LESetExtendedScanParametersCommand_EmbossReservedAnonymousField7<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetExtendedScanParametersCommand_EmbossReservedAnonymousField7<S>

where S: Storage,

type Ok = LESetExtendedScanParametersCommand_EmbossReservedAnonymousField7<S, OkState>

fn check_ok( self, ) -> Result<<LESetExtendedScanParametersCommand_EmbossReservedAnonymousField7<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetExtendedScanParametersCommand_EmbossReservedAnonymousField7Writer<S, CompleteState>

where S: MutStorage,

type Ok = LESetExtendedScanParametersCommand_EmbossReservedAnonymousField7Writer<S, OkState>

fn check_ok( self, ) -> Result<<LESetExtendedScanParametersCommand_EmbossReservedAnonymousField7Writer<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetExtendedScanParametersCommand_EmbossReservedAnonymousField7Writer<S, OkState>

where S: MutStorage,

type Ok = LESetExtendedScanParametersCommand_EmbossReservedAnonymousField7Writer<S, OkState>

fn check_ok( self, ) -> Result<<LESetExtendedScanParametersCommand_EmbossReservedAnonymousField7Writer<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetExtendedScanParametersCommand_EmbossReservedAnonymousField7Writer<S>

where S: MutStorage,

type Ok = LESetExtendedScanParametersCommand_EmbossReservedAnonymousField7Writer<S, OkState>

fn check_ok( self, ) -> Result<<LESetExtendedScanParametersCommand_EmbossReservedAnonymousField7Writer<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetExtendedScanParametersData<S, CompleteState>

where S: Storage,

type Ok = LESetExtendedScanParametersData<S, OkState>

fn check_ok( self, ) -> Result<<LESetExtendedScanParametersData<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetExtendedScanParametersData<S, OkState>

where S: Storage,

type Ok = LESetExtendedScanParametersData<S, OkState>

fn check_ok( self, ) -> Result<<LESetExtendedScanParametersData<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetExtendedScanParametersData<S>

where S: Storage,

type Ok = LESetExtendedScanParametersData<S, OkState>

fn check_ok( self, ) -> Result<<LESetExtendedScanParametersData<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetExtendedScanParametersDataWriter<S, CompleteState>

where S: MutStorage,

type Ok = LESetExtendedScanParametersDataWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetExtendedScanParametersDataWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetExtendedScanParametersDataWriter<S, OkState>

where S: MutStorage,

type Ok = LESetExtendedScanParametersDataWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetExtendedScanParametersDataWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetExtendedScanParametersDataWriter<S>

where S: MutStorage,

type Ok = LESetExtendedScanParametersDataWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetExtendedScanParametersDataWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetExtendedScanResponseDataCommand<S, CompleteState>

where S: Storage,

type Ok = LESetExtendedScanResponseDataCommand<S, OkState>

fn check_ok( self, ) -> Result<<LESetExtendedScanResponseDataCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetExtendedScanResponseDataCommand<S, OkState>

where S: Storage,

type Ok = LESetExtendedScanResponseDataCommand<S, OkState>

fn check_ok( self, ) -> Result<<LESetExtendedScanResponseDataCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetExtendedScanResponseDataCommand<S>

where S: Storage,

type Ok = LESetExtendedScanResponseDataCommand<S, OkState>

fn check_ok( self, ) -> Result<<LESetExtendedScanResponseDataCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetExtendedScanResponseDataCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = LESetExtendedScanResponseDataCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetExtendedScanResponseDataCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetExtendedScanResponseDataCommandWriter<S, OkState>

where S: MutStorage,

type Ok = LESetExtendedScanResponseDataCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetExtendedScanResponseDataCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetExtendedScanResponseDataCommandWriter<S>

where S: MutStorage,

type Ok = LESetExtendedScanResponseDataCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetExtendedScanResponseDataCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetHostFeatureCommand<S, CompleteState>

where S: Storage,

type Ok = LESetHostFeatureCommand<S, OkState>

fn check_ok( self, ) -> Result<<LESetHostFeatureCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetHostFeatureCommand<S, OkState>

where S: Storage,

type Ok = LESetHostFeatureCommand<S, OkState>

fn check_ok( self, ) -> Result<<LESetHostFeatureCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetHostFeatureCommand<S>

where S: Storage,

type Ok = LESetHostFeatureCommand<S, OkState>

fn check_ok(self) -> Result<<LESetHostFeatureCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetHostFeatureCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = LESetHostFeatureCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetHostFeatureCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetHostFeatureCommandWriter<S, OkState>

where S: MutStorage,

type Ok = LESetHostFeatureCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetHostFeatureCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetHostFeatureCommandWriter<S>

where S: MutStorage,

type Ok = LESetHostFeatureCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetHostFeatureCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetPeriodicAdvertisingSyncTransferParametersCommand<S, CompleteState>

where S: Storage,

type Ok = LESetPeriodicAdvertisingSyncTransferParametersCommand<S, OkState>

fn check_ok( self, ) -> Result<<LESetPeriodicAdvertisingSyncTransferParametersCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetPeriodicAdvertisingSyncTransferParametersCommand<S, OkState>

where S: Storage,

type Ok = LESetPeriodicAdvertisingSyncTransferParametersCommand<S, OkState>

fn check_ok( self, ) -> Result<<LESetPeriodicAdvertisingSyncTransferParametersCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetPeriodicAdvertisingSyncTransferParametersCommand<S>

where S: Storage,

type Ok = LESetPeriodicAdvertisingSyncTransferParametersCommand<S, OkState>

fn check_ok( self, ) -> Result<<LESetPeriodicAdvertisingSyncTransferParametersCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetPeriodicAdvertisingSyncTransferParametersCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = LESetPeriodicAdvertisingSyncTransferParametersCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetPeriodicAdvertisingSyncTransferParametersCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetPeriodicAdvertisingSyncTransferParametersCommandWriter<S, OkState>

where S: MutStorage,

type Ok = LESetPeriodicAdvertisingSyncTransferParametersCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetPeriodicAdvertisingSyncTransferParametersCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetPeriodicAdvertisingSyncTransferParametersCommandWriter<S>

where S: MutStorage,

type Ok = LESetPeriodicAdvertisingSyncTransferParametersCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetPeriodicAdvertisingSyncTransferParametersCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetPeriodicAdvertisingSyncTransferParametersCommand_EmbossReservedAnonymousField2<S, CompleteState>

where S: Storage,

type Ok = LESetPeriodicAdvertisingSyncTransferParametersCommand_EmbossReservedAnonymousField2<S, OkState>

fn check_ok( self, ) -> Result<<LESetPeriodicAdvertisingSyncTransferParametersCommand_EmbossReservedAnonymousField2<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetPeriodicAdvertisingSyncTransferParametersCommand_EmbossReservedAnonymousField2<S, OkState>

where S: Storage,

type Ok = LESetPeriodicAdvertisingSyncTransferParametersCommand_EmbossReservedAnonymousField2<S, OkState>

fn check_ok( self, ) -> Result<<LESetPeriodicAdvertisingSyncTransferParametersCommand_EmbossReservedAnonymousField2<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetPeriodicAdvertisingSyncTransferParametersCommand_EmbossReservedAnonymousField2<S>

where S: Storage,

type Ok = LESetPeriodicAdvertisingSyncTransferParametersCommand_EmbossReservedAnonymousField2<S, OkState>

fn check_ok( self, ) -> Result<<LESetPeriodicAdvertisingSyncTransferParametersCommand_EmbossReservedAnonymousField2<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetPeriodicAdvertisingSyncTransferParametersCommand_EmbossReservedAnonymousField2Writer<S, CompleteState>

where S: MutStorage,

type Ok = LESetPeriodicAdvertisingSyncTransferParametersCommand_EmbossReservedAnonymousField2Writer<S, OkState>

fn check_ok( self, ) -> Result<<LESetPeriodicAdvertisingSyncTransferParametersCommand_EmbossReservedAnonymousField2Writer<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetPeriodicAdvertisingSyncTransferParametersCommand_EmbossReservedAnonymousField2Writer<S, OkState>

where S: MutStorage,

type Ok = LESetPeriodicAdvertisingSyncTransferParametersCommand_EmbossReservedAnonymousField2Writer<S, OkState>

fn check_ok( self, ) -> Result<<LESetPeriodicAdvertisingSyncTransferParametersCommand_EmbossReservedAnonymousField2Writer<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetPeriodicAdvertisingSyncTransferParametersCommand_EmbossReservedAnonymousField2Writer<S>

where S: MutStorage,

type Ok = LESetPeriodicAdvertisingSyncTransferParametersCommand_EmbossReservedAnonymousField2Writer<S, OkState>

fn check_ok( self, ) -> Result<<LESetPeriodicAdvertisingSyncTransferParametersCommand_EmbossReservedAnonymousField2Writer<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetPeriodicSyncSubeventCommand<S, CompleteState>

where S: Storage,

type Ok = LESetPeriodicSyncSubeventCommand<S, OkState>

fn check_ok( self, ) -> Result<<LESetPeriodicSyncSubeventCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetPeriodicSyncSubeventCommand<S, OkState>

where S: Storage,

type Ok = LESetPeriodicSyncSubeventCommand<S, OkState>

fn check_ok( self, ) -> Result<<LESetPeriodicSyncSubeventCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetPeriodicSyncSubeventCommand<S>

where S: Storage,

type Ok = LESetPeriodicSyncSubeventCommand<S, OkState>

fn check_ok( self, ) -> Result<<LESetPeriodicSyncSubeventCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetPeriodicSyncSubeventCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = LESetPeriodicSyncSubeventCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetPeriodicSyncSubeventCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetPeriodicSyncSubeventCommandWriter<S, OkState>

where S: MutStorage,

type Ok = LESetPeriodicSyncSubeventCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetPeriodicSyncSubeventCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetPeriodicSyncSubeventCommandWriter<S>

where S: MutStorage,

type Ok = LESetPeriodicSyncSubeventCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetPeriodicSyncSubeventCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetPeriodicSyncSubeventCommand_EmbossReservedAnonymousField3<S, CompleteState>

where S: Storage,

type Ok = LESetPeriodicSyncSubeventCommand_EmbossReservedAnonymousField3<S, OkState>

fn check_ok( self, ) -> Result<<LESetPeriodicSyncSubeventCommand_EmbossReservedAnonymousField3<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetPeriodicSyncSubeventCommand_EmbossReservedAnonymousField3<S, OkState>

where S: Storage,

type Ok = LESetPeriodicSyncSubeventCommand_EmbossReservedAnonymousField3<S, OkState>

fn check_ok( self, ) -> Result<<LESetPeriodicSyncSubeventCommand_EmbossReservedAnonymousField3<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetPeriodicSyncSubeventCommand_EmbossReservedAnonymousField3<S>

where S: Storage,

type Ok = LESetPeriodicSyncSubeventCommand_EmbossReservedAnonymousField3<S, OkState>

fn check_ok( self, ) -> Result<<LESetPeriodicSyncSubeventCommand_EmbossReservedAnonymousField3<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetPeriodicSyncSubeventCommand_EmbossReservedAnonymousField3Writer<S, CompleteState>

where S: MutStorage,

type Ok = LESetPeriodicSyncSubeventCommand_EmbossReservedAnonymousField3Writer<S, OkState>

fn check_ok( self, ) -> Result<<LESetPeriodicSyncSubeventCommand_EmbossReservedAnonymousField3Writer<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetPeriodicSyncSubeventCommand_EmbossReservedAnonymousField3Writer<S, OkState>

where S: MutStorage,

type Ok = LESetPeriodicSyncSubeventCommand_EmbossReservedAnonymousField3Writer<S, OkState>

fn check_ok( self, ) -> Result<<LESetPeriodicSyncSubeventCommand_EmbossReservedAnonymousField3Writer<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetPeriodicSyncSubeventCommand_EmbossReservedAnonymousField3Writer<S>

where S: MutStorage,

type Ok = LESetPeriodicSyncSubeventCommand_EmbossReservedAnonymousField3Writer<S, OkState>

fn check_ok( self, ) -> Result<<LESetPeriodicSyncSubeventCommand_EmbossReservedAnonymousField3Writer<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetPrivacyModeCommand<S, CompleteState>

where S: Storage,

type Ok = LESetPrivacyModeCommand<S, OkState>

fn check_ok( self, ) -> Result<<LESetPrivacyModeCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetPrivacyModeCommand<S, OkState>

where S: Storage,

type Ok = LESetPrivacyModeCommand<S, OkState>

fn check_ok( self, ) -> Result<<LESetPrivacyModeCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetPrivacyModeCommand<S>

where S: Storage,

type Ok = LESetPrivacyModeCommand<S, OkState>

fn check_ok(self) -> Result<<LESetPrivacyModeCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetPrivacyModeCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = LESetPrivacyModeCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetPrivacyModeCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetPrivacyModeCommandWriter<S, OkState>

where S: MutStorage,

type Ok = LESetPrivacyModeCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetPrivacyModeCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetPrivacyModeCommandWriter<S>

where S: MutStorage,

type Ok = LESetPrivacyModeCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetPrivacyModeCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetRandomAddressCommand<S, CompleteState>

where S: Storage,

type Ok = LESetRandomAddressCommand<S, OkState>

fn check_ok( self, ) -> Result<<LESetRandomAddressCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetRandomAddressCommand<S, OkState>

where S: Storage,

type Ok = LESetRandomAddressCommand<S, OkState>

fn check_ok( self, ) -> Result<<LESetRandomAddressCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetRandomAddressCommand<S>

where S: Storage,

type Ok = LESetRandomAddressCommand<S, OkState>

fn check_ok( self, ) -> Result<<LESetRandomAddressCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetRandomAddressCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = LESetRandomAddressCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetRandomAddressCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetRandomAddressCommandWriter<S, OkState>

where S: MutStorage,

type Ok = LESetRandomAddressCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetRandomAddressCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetRandomAddressCommandWriter<S>

where S: MutStorage,

type Ok = LESetRandomAddressCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetRandomAddressCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetScanEnableCommand<S, CompleteState>

where S: Storage,

type Ok = LESetScanEnableCommand<S, OkState>

fn check_ok( self, ) -> Result<<LESetScanEnableCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetScanEnableCommand<S, OkState>

where S: Storage,

type Ok = LESetScanEnableCommand<S, OkState>

fn check_ok( self, ) -> Result<<LESetScanEnableCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetScanEnableCommand<S>

where S: Storage,

type Ok = LESetScanEnableCommand<S, OkState>

fn check_ok(self) -> Result<<LESetScanEnableCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetScanEnableCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = LESetScanEnableCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetScanEnableCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetScanEnableCommandWriter<S, OkState>

where S: MutStorage,

type Ok = LESetScanEnableCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetScanEnableCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetScanEnableCommandWriter<S>

where S: MutStorage,

type Ok = LESetScanEnableCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetScanEnableCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetScanParametersCommand<S, CompleteState>

where S: Storage,

type Ok = LESetScanParametersCommand<S, OkState>

fn check_ok( self, ) -> Result<<LESetScanParametersCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetScanParametersCommand<S, OkState>

where S: Storage,

type Ok = LESetScanParametersCommand<S, OkState>

fn check_ok( self, ) -> Result<<LESetScanParametersCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetScanParametersCommand<S>

where S: Storage,

type Ok = LESetScanParametersCommand<S, OkState>

fn check_ok( self, ) -> Result<<LESetScanParametersCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetScanParametersCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = LESetScanParametersCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetScanParametersCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetScanParametersCommandWriter<S, OkState>

where S: MutStorage,

type Ok = LESetScanParametersCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetScanParametersCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetScanParametersCommandWriter<S>

where S: MutStorage,

type Ok = LESetScanParametersCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetScanParametersCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetScanResponseDataCommand<S, CompleteState>

where S: Storage,

type Ok = LESetScanResponseDataCommand<S, OkState>

fn check_ok( self, ) -> Result<<LESetScanResponseDataCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetScanResponseDataCommand<S, OkState>

where S: Storage,

type Ok = LESetScanResponseDataCommand<S, OkState>

fn check_ok( self, ) -> Result<<LESetScanResponseDataCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetScanResponseDataCommand<S>

where S: Storage,

type Ok = LESetScanResponseDataCommand<S, OkState>

fn check_ok( self, ) -> Result<<LESetScanResponseDataCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetScanResponseDataCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = LESetScanResponseDataCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetScanResponseDataCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetScanResponseDataCommandWriter<S, OkState>

where S: MutStorage,

type Ok = LESetScanResponseDataCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetScanResponseDataCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetScanResponseDataCommandWriter<S>

where S: MutStorage,

type Ok = LESetScanResponseDataCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetScanResponseDataCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetupISODataPathCommand<S, CompleteState>

where S: Storage,

type Ok = LESetupISODataPathCommand<S, OkState>

fn check_ok( self, ) -> Result<<LESetupISODataPathCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetupISODataPathCommand<S, OkState>

where S: Storage,

type Ok = LESetupISODataPathCommand<S, OkState>

fn check_ok( self, ) -> Result<<LESetupISODataPathCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetupISODataPathCommand<S>

where S: Storage,

type Ok = LESetupISODataPathCommand<S, OkState>

fn check_ok( self, ) -> Result<<LESetupISODataPathCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetupISODataPathCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = LESetupISODataPathCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetupISODataPathCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetupISODataPathCommandWriter<S, OkState>

where S: MutStorage,

type Ok = LESetupISODataPathCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetupISODataPathCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LESetupISODataPathCommandWriter<S>

where S: MutStorage,

type Ok = LESetupISODataPathCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LESetupISODataPathCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEWriteRFPathCompensationCommand<S, CompleteState>

where S: Storage,

type Ok = LEWriteRFPathCompensationCommand<S, OkState>

fn check_ok( self, ) -> Result<<LEWriteRFPathCompensationCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEWriteRFPathCompensationCommand<S, OkState>

where S: Storage,

type Ok = LEWriteRFPathCompensationCommand<S, OkState>

fn check_ok( self, ) -> Result<<LEWriteRFPathCompensationCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEWriteRFPathCompensationCommand<S>

where S: Storage,

type Ok = LEWriteRFPathCompensationCommand<S, OkState>

fn check_ok( self, ) -> Result<<LEWriteRFPathCompensationCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEWriteRFPathCompensationCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = LEWriteRFPathCompensationCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEWriteRFPathCompensationCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEWriteRFPathCompensationCommandWriter<S, OkState>

where S: MutStorage,

type Ok = LEWriteRFPathCompensationCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEWriteRFPathCompensationCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LEWriteRFPathCompensationCommandWriter<S>

where S: MutStorage,

type Ok = LEWriteRFPathCompensationCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LEWriteRFPathCompensationCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LinkKey<S, CompleteState>

where S: Storage,

type Ok = LinkKey<S, OkState>

fn check_ok(self) -> Result<<LinkKey<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LinkKey<S, OkState>

where S: Storage,

type Ok = LinkKey<S, OkState>

fn check_ok(self) -> Result<<LinkKey<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LinkKey<S>

where S: Storage,

type Ok = LinkKey<S, OkState>

fn check_ok(self) -> Result<<LinkKey<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LinkKeyRequestNegativeReplyCommand<S, CompleteState>

where S: Storage,

type Ok = LinkKeyRequestNegativeReplyCommand<S, OkState>

fn check_ok( self, ) -> Result<<LinkKeyRequestNegativeReplyCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LinkKeyRequestNegativeReplyCommand<S, OkState>

where S: Storage,

type Ok = LinkKeyRequestNegativeReplyCommand<S, OkState>

fn check_ok( self, ) -> Result<<LinkKeyRequestNegativeReplyCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LinkKeyRequestNegativeReplyCommand<S>

where S: Storage,

type Ok = LinkKeyRequestNegativeReplyCommand<S, OkState>

fn check_ok( self, ) -> Result<<LinkKeyRequestNegativeReplyCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LinkKeyRequestNegativeReplyCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = LinkKeyRequestNegativeReplyCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LinkKeyRequestNegativeReplyCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LinkKeyRequestNegativeReplyCommandWriter<S, OkState>

where S: MutStorage,

type Ok = LinkKeyRequestNegativeReplyCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LinkKeyRequestNegativeReplyCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LinkKeyRequestNegativeReplyCommandWriter<S>

where S: MutStorage,

type Ok = LinkKeyRequestNegativeReplyCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LinkKeyRequestNegativeReplyCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LinkKeyRequestReplyCommand<S, CompleteState>

where S: Storage,

type Ok = LinkKeyRequestReplyCommand<S, OkState>

fn check_ok( self, ) -> Result<<LinkKeyRequestReplyCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LinkKeyRequestReplyCommand<S, OkState>

where S: Storage,

type Ok = LinkKeyRequestReplyCommand<S, OkState>

fn check_ok( self, ) -> Result<<LinkKeyRequestReplyCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LinkKeyRequestReplyCommand<S>

where S: Storage,

type Ok = LinkKeyRequestReplyCommand<S, OkState>

fn check_ok( self, ) -> Result<<LinkKeyRequestReplyCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LinkKeyRequestReplyCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = LinkKeyRequestReplyCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LinkKeyRequestReplyCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LinkKeyRequestReplyCommandWriter<S, OkState>

where S: MutStorage,

type Ok = LinkKeyRequestReplyCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LinkKeyRequestReplyCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LinkKeyRequestReplyCommandWriter<S>

where S: MutStorage,

type Ok = LinkKeyRequestReplyCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<LinkKeyRequestReplyCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LinkKeyWriter<S, CompleteState>

where S: MutStorage,

type Ok = LinkKeyWriter<S, OkState>

fn check_ok( self, ) -> Result<<LinkKeyWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LinkKeyWriter<S, OkState>

where S: MutStorage,

type Ok = LinkKeyWriter<S, OkState>

fn check_ok(self) -> Result<<LinkKeyWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LinkKeyWriter<S>

where S: MutStorage,

type Ok = LinkKeyWriter<S, OkState>

fn check_ok(self) -> Result<<LinkKeyWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LinkPolicySettings<S, CompleteState>

where S: Storage,

type Ok = LinkPolicySettings<S, OkState>

fn check_ok( self, ) -> Result<<LinkPolicySettings<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LinkPolicySettings<S, OkState>

where S: Storage,

type Ok = LinkPolicySettings<S, OkState>

fn check_ok( self, ) -> Result<<LinkPolicySettings<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LinkPolicySettings<S>

where S: Storage,

type Ok = LinkPolicySettings<S, OkState>

fn check_ok(self) -> Result<<LinkPolicySettings<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LinkPolicySettingsWriter<S, CompleteState>

where S: MutStorage,

type Ok = LinkPolicySettingsWriter<S, OkState>

fn check_ok( self, ) -> Result<<LinkPolicySettingsWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LinkPolicySettingsWriter<S, OkState>

where S: MutStorage,

type Ok = LinkPolicySettingsWriter<S, OkState>

fn check_ok( self, ) -> Result<<LinkPolicySettingsWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LinkPolicySettingsWriter<S>

where S: MutStorage,

type Ok = LinkPolicySettingsWriter<S, OkState>

fn check_ok(self) -> Result<<LinkPolicySettingsWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LocalName<S, CompleteState>

where S: Storage,

type Ok = LocalName<S, OkState>

fn check_ok(self) -> Result<<LocalName<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LocalName<S, OkState>

where S: Storage,

type Ok = LocalName<S, OkState>

fn check_ok(self) -> Result<<LocalName<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LocalName<S>

where S: Storage,

type Ok = LocalName<S, OkState>

fn check_ok(self) -> Result<<LocalName<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for LocalNameWriter<S, CompleteState>

where S: MutStorage,

type Ok = LocalNameWriter<S, OkState>

fn check_ok( self, ) -> Result<<LocalNameWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LocalNameWriter<S, OkState>

where S: MutStorage,

type Ok = LocalNameWriter<S, OkState>

fn check_ok(self) -> Result<<LocalNameWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for LocalNameWriter<S>

where S: MutStorage,

type Ok = LocalNameWriter<S, OkState>

fn check_ok(self) -> Result<<LocalNameWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for MajorServiceClasses<S, CompleteState>

where S: Storage,

type Ok = MajorServiceClasses<S, OkState>

fn check_ok( self, ) -> Result<<MajorServiceClasses<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for MajorServiceClasses<S, OkState>

where S: Storage,

type Ok = MajorServiceClasses<S, OkState>

fn check_ok( self, ) -> Result<<MajorServiceClasses<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for MajorServiceClasses<S>

where S: Storage,

type Ok = MajorServiceClasses<S, OkState>

fn check_ok(self) -> Result<<MajorServiceClasses<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for MajorServiceClassesWriter<S, CompleteState>

where S: MutStorage,

type Ok = MajorServiceClassesWriter<S, OkState>

fn check_ok( self, ) -> Result<<MajorServiceClassesWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for MajorServiceClassesWriter<S, OkState>

where S: MutStorage,

type Ok = MajorServiceClassesWriter<S, OkState>

fn check_ok( self, ) -> Result<<MajorServiceClassesWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for MajorServiceClassesWriter<S>

where S: MutStorage,

type Ok = MajorServiceClassesWriter<S, OkState>

fn check_ok( self, ) -> Result<<MajorServiceClassesWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for OpCodeBits<S, CompleteState>

where S: Storage,

type Ok = OpCodeBits<S, OkState>

fn check_ok( self, ) -> Result<<OpCodeBits<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for OpCodeBits<S, OkState>

where S: Storage,

type Ok = OpCodeBits<S, OkState>

fn check_ok(self) -> Result<<OpCodeBits<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for OpCodeBits<S>

where S: Storage,

type Ok = OpCodeBits<S, OkState>

fn check_ok(self) -> Result<<OpCodeBits<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for OpCodeBitsWriter<S, CompleteState>

where S: MutStorage,

type Ok = OpCodeBitsWriter<S, OkState>

fn check_ok( self, ) -> Result<<OpCodeBitsWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for OpCodeBitsWriter<S, OkState>

where S: MutStorage,

type Ok = OpCodeBitsWriter<S, OkState>

fn check_ok( self, ) -> Result<<OpCodeBitsWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for OpCodeBitsWriter<S>

where S: MutStorage,

type Ok = OpCodeBitsWriter<S, OkState>

fn check_ok(self) -> Result<<OpCodeBitsWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for PacketType<S, CompleteState>

where S: Storage,

type Ok = PacketType<S, OkState>

fn check_ok( self, ) -> Result<<PacketType<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for PacketType<S, OkState>

where S: Storage,

type Ok = PacketType<S, OkState>

fn check_ok(self) -> Result<<PacketType<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for PacketType<S>

where S: Storage,

type Ok = PacketType<S, OkState>

fn check_ok(self) -> Result<<PacketType<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for PacketTypeWriter<S, CompleteState>

where S: MutStorage,

type Ok = PacketTypeWriter<S, OkState>

fn check_ok( self, ) -> Result<<PacketTypeWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for PacketTypeWriter<S, OkState>

where S: MutStorage,

type Ok = PacketTypeWriter<S, OkState>

fn check_ok( self, ) -> Result<<PacketTypeWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for PacketTypeWriter<S>

where S: MutStorage,

type Ok = PacketTypeWriter<S, OkState>

fn check_ok(self) -> Result<<PacketTypeWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for PeriodicAdvertisingProperties<S, CompleteState>

where S: Storage,

type Ok = PeriodicAdvertisingProperties<S, OkState>

fn check_ok( self, ) -> Result<<PeriodicAdvertisingProperties<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for PeriodicAdvertisingProperties<S, OkState>

where S: Storage,

type Ok = PeriodicAdvertisingProperties<S, OkState>

fn check_ok( self, ) -> Result<<PeriodicAdvertisingProperties<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for PeriodicAdvertisingProperties<S>

where S: Storage,

type Ok = PeriodicAdvertisingProperties<S, OkState>

fn check_ok( self, ) -> Result<<PeriodicAdvertisingProperties<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for PeriodicAdvertisingPropertiesWriter<S, CompleteState>

where S: MutStorage,

type Ok = PeriodicAdvertisingPropertiesWriter<S, OkState>

fn check_ok( self, ) -> Result<<PeriodicAdvertisingPropertiesWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for PeriodicAdvertisingPropertiesWriter<S, OkState>

where S: MutStorage,

type Ok = PeriodicAdvertisingPropertiesWriter<S, OkState>

fn check_ok( self, ) -> Result<<PeriodicAdvertisingPropertiesWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for PeriodicAdvertisingPropertiesWriter<S>

where S: MutStorage,

type Ok = PeriodicAdvertisingPropertiesWriter<S, OkState>

fn check_ok( self, ) -> Result<<PeriodicAdvertisingPropertiesWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for PeripheralMinorDeviceClass<S, CompleteState>

where S: Storage,

type Ok = PeripheralMinorDeviceClass<S, OkState>

fn check_ok( self, ) -> Result<<PeripheralMinorDeviceClass<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for PeripheralMinorDeviceClass<S, OkState>

where S: Storage,

type Ok = PeripheralMinorDeviceClass<S, OkState>

fn check_ok( self, ) -> Result<<PeripheralMinorDeviceClass<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for PeripheralMinorDeviceClass<S>

where S: Storage,

type Ok = PeripheralMinorDeviceClass<S, OkState>

fn check_ok( self, ) -> Result<<PeripheralMinorDeviceClass<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for PeripheralMinorDeviceClassWriter<S, CompleteState>

where S: MutStorage,

type Ok = PeripheralMinorDeviceClassWriter<S, OkState>

fn check_ok( self, ) -> Result<<PeripheralMinorDeviceClassWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for PeripheralMinorDeviceClassWriter<S, OkState>

where S: MutStorage,

type Ok = PeripheralMinorDeviceClassWriter<S, OkState>

fn check_ok( self, ) -> Result<<PeripheralMinorDeviceClassWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for PeripheralMinorDeviceClassWriter<S>

where S: MutStorage,

type Ok = PeripheralMinorDeviceClassWriter<S, OkState>

fn check_ok( self, ) -> Result<<PeripheralMinorDeviceClassWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for PinCodeRequestNegativeReplyCommand<S, CompleteState>

where S: Storage,

type Ok = PinCodeRequestNegativeReplyCommand<S, OkState>

fn check_ok( self, ) -> Result<<PinCodeRequestNegativeReplyCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for PinCodeRequestNegativeReplyCommand<S, OkState>

where S: Storage,

type Ok = PinCodeRequestNegativeReplyCommand<S, OkState>

fn check_ok( self, ) -> Result<<PinCodeRequestNegativeReplyCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for PinCodeRequestNegativeReplyCommand<S>

where S: Storage,

type Ok = PinCodeRequestNegativeReplyCommand<S, OkState>

fn check_ok( self, ) -> Result<<PinCodeRequestNegativeReplyCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for PinCodeRequestNegativeReplyCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = PinCodeRequestNegativeReplyCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<PinCodeRequestNegativeReplyCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for PinCodeRequestNegativeReplyCommandWriter<S, OkState>

where S: MutStorage,

type Ok = PinCodeRequestNegativeReplyCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<PinCodeRequestNegativeReplyCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for PinCodeRequestNegativeReplyCommandWriter<S>

where S: MutStorage,

type Ok = PinCodeRequestNegativeReplyCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<PinCodeRequestNegativeReplyCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for PinCodeRequestReplyCommand<S, CompleteState>

where S: Storage,

type Ok = PinCodeRequestReplyCommand<S, OkState>

fn check_ok( self, ) -> Result<<PinCodeRequestReplyCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for PinCodeRequestReplyCommand<S, OkState>

where S: Storage,

type Ok = PinCodeRequestReplyCommand<S, OkState>

fn check_ok( self, ) -> Result<<PinCodeRequestReplyCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for PinCodeRequestReplyCommand<S>

where S: Storage,

type Ok = PinCodeRequestReplyCommand<S, OkState>

fn check_ok( self, ) -> Result<<PinCodeRequestReplyCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for PinCodeRequestReplyCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = PinCodeRequestReplyCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<PinCodeRequestReplyCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for PinCodeRequestReplyCommandWriter<S, OkState>

where S: MutStorage,

type Ok = PinCodeRequestReplyCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<PinCodeRequestReplyCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for PinCodeRequestReplyCommandWriter<S>

where S: MutStorage,

type Ok = PinCodeRequestReplyCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<PinCodeRequestReplyCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadAuthenticatedPayloadTimeoutCommand<S, CompleteState>

where S: Storage,

type Ok = ReadAuthenticatedPayloadTimeoutCommand<S, OkState>

fn check_ok( self, ) -> Result<<ReadAuthenticatedPayloadTimeoutCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadAuthenticatedPayloadTimeoutCommand<S, OkState>

where S: Storage,

type Ok = ReadAuthenticatedPayloadTimeoutCommand<S, OkState>

fn check_ok( self, ) -> Result<<ReadAuthenticatedPayloadTimeoutCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadAuthenticatedPayloadTimeoutCommand<S>

where S: Storage,

type Ok = ReadAuthenticatedPayloadTimeoutCommand<S, OkState>

fn check_ok( self, ) -> Result<<ReadAuthenticatedPayloadTimeoutCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadAuthenticatedPayloadTimeoutCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = ReadAuthenticatedPayloadTimeoutCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadAuthenticatedPayloadTimeoutCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadAuthenticatedPayloadTimeoutCommandWriter<S, OkState>

where S: MutStorage,

type Ok = ReadAuthenticatedPayloadTimeoutCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadAuthenticatedPayloadTimeoutCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadAuthenticatedPayloadTimeoutCommandWriter<S>

where S: MutStorage,

type Ok = ReadAuthenticatedPayloadTimeoutCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadAuthenticatedPayloadTimeoutCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadBdAddrCommand<S, CompleteState>

where S: Storage,

type Ok = ReadBdAddrCommand<S, OkState>

fn check_ok( self, ) -> Result<<ReadBdAddrCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadBdAddrCommand<S, OkState>

where S: Storage,

type Ok = ReadBdAddrCommand<S, OkState>

fn check_ok( self, ) -> Result<<ReadBdAddrCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadBdAddrCommand<S>

where S: Storage,

type Ok = ReadBdAddrCommand<S, OkState>

fn check_ok(self) -> Result<<ReadBdAddrCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadBdAddrCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = ReadBdAddrCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadBdAddrCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadBdAddrCommandWriter<S, OkState>

where S: MutStorage,

type Ok = ReadBdAddrCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadBdAddrCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadBdAddrCommandWriter<S>

where S: MutStorage,

type Ok = ReadBdAddrCommandWriter<S, OkState>

fn check_ok(self) -> Result<<ReadBdAddrCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadBufferSizeCommand<S, CompleteState>

where S: Storage,

type Ok = ReadBufferSizeCommand<S, OkState>

fn check_ok( self, ) -> Result<<ReadBufferSizeCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadBufferSizeCommand<S, OkState>

where S: Storage,

type Ok = ReadBufferSizeCommand<S, OkState>

fn check_ok( self, ) -> Result<<ReadBufferSizeCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadBufferSizeCommand<S>

where S: Storage,

type Ok = ReadBufferSizeCommand<S, OkState>

fn check_ok(self) -> Result<<ReadBufferSizeCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadBufferSizeCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = ReadBufferSizeCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadBufferSizeCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadBufferSizeCommandWriter<S, OkState>

where S: MutStorage,

type Ok = ReadBufferSizeCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadBufferSizeCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadBufferSizeCommandWriter<S>

where S: MutStorage,

type Ok = ReadBufferSizeCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadBufferSizeCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadClassOfDeviceCommand<S, CompleteState>

where S: Storage,

type Ok = ReadClassOfDeviceCommand<S, OkState>

fn check_ok( self, ) -> Result<<ReadClassOfDeviceCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadClassOfDeviceCommand<S, OkState>

where S: Storage,

type Ok = ReadClassOfDeviceCommand<S, OkState>

fn check_ok( self, ) -> Result<<ReadClassOfDeviceCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadClassOfDeviceCommand<S>

where S: Storage,

type Ok = ReadClassOfDeviceCommand<S, OkState>

fn check_ok(self) -> Result<<ReadClassOfDeviceCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadClassOfDeviceCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = ReadClassOfDeviceCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadClassOfDeviceCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadClassOfDeviceCommandWriter<S, OkState>

where S: MutStorage,

type Ok = ReadClassOfDeviceCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadClassOfDeviceCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadClassOfDeviceCommandWriter<S>

where S: MutStorage,

type Ok = ReadClassOfDeviceCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadClassOfDeviceCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadEncryptionKeySizeCommand<S, CompleteState>

where S: Storage,

type Ok = ReadEncryptionKeySizeCommand<S, OkState>

fn check_ok( self, ) -> Result<<ReadEncryptionKeySizeCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadEncryptionKeySizeCommand<S, OkState>

where S: Storage,

type Ok = ReadEncryptionKeySizeCommand<S, OkState>

fn check_ok( self, ) -> Result<<ReadEncryptionKeySizeCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadEncryptionKeySizeCommand<S>

where S: Storage,

type Ok = ReadEncryptionKeySizeCommand<S, OkState>

fn check_ok( self, ) -> Result<<ReadEncryptionKeySizeCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadEncryptionKeySizeCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = ReadEncryptionKeySizeCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadEncryptionKeySizeCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadEncryptionKeySizeCommandWriter<S, OkState>

where S: MutStorage,

type Ok = ReadEncryptionKeySizeCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadEncryptionKeySizeCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadEncryptionKeySizeCommandWriter<S>

where S: MutStorage,

type Ok = ReadEncryptionKeySizeCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadEncryptionKeySizeCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadFlowControlModeCommand<S, CompleteState>

where S: Storage,

type Ok = ReadFlowControlModeCommand<S, OkState>

fn check_ok( self, ) -> Result<<ReadFlowControlModeCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadFlowControlModeCommand<S, OkState>

where S: Storage,

type Ok = ReadFlowControlModeCommand<S, OkState>

fn check_ok( self, ) -> Result<<ReadFlowControlModeCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadFlowControlModeCommand<S>

where S: Storage,

type Ok = ReadFlowControlModeCommand<S, OkState>

fn check_ok( self, ) -> Result<<ReadFlowControlModeCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadFlowControlModeCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = ReadFlowControlModeCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadFlowControlModeCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadFlowControlModeCommandWriter<S, OkState>

where S: MutStorage,

type Ok = ReadFlowControlModeCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadFlowControlModeCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadFlowControlModeCommandWriter<S>

where S: MutStorage,

type Ok = ReadFlowControlModeCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadFlowControlModeCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadInquiryModeCommand<S, CompleteState>

where S: Storage,

type Ok = ReadInquiryModeCommand<S, OkState>

fn check_ok( self, ) -> Result<<ReadInquiryModeCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadInquiryModeCommand<S, OkState>

where S: Storage,

type Ok = ReadInquiryModeCommand<S, OkState>

fn check_ok( self, ) -> Result<<ReadInquiryModeCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadInquiryModeCommand<S>

where S: Storage,

type Ok = ReadInquiryModeCommand<S, OkState>

fn check_ok(self) -> Result<<ReadInquiryModeCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadInquiryModeCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = ReadInquiryModeCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadInquiryModeCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadInquiryModeCommandWriter<S, OkState>

where S: MutStorage,

type Ok = ReadInquiryModeCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadInquiryModeCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadInquiryModeCommandWriter<S>

where S: MutStorage,

type Ok = ReadInquiryModeCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadInquiryModeCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadInquiryScanActivityCommand<S, CompleteState>

where S: Storage,

type Ok = ReadInquiryScanActivityCommand<S, OkState>

fn check_ok( self, ) -> Result<<ReadInquiryScanActivityCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadInquiryScanActivityCommand<S, OkState>

where S: Storage,

type Ok = ReadInquiryScanActivityCommand<S, OkState>

fn check_ok( self, ) -> Result<<ReadInquiryScanActivityCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadInquiryScanActivityCommand<S>

where S: Storage,

type Ok = ReadInquiryScanActivityCommand<S, OkState>

fn check_ok( self, ) -> Result<<ReadInquiryScanActivityCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadInquiryScanActivityCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = ReadInquiryScanActivityCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadInquiryScanActivityCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadInquiryScanActivityCommandWriter<S, OkState>

where S: MutStorage,

type Ok = ReadInquiryScanActivityCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadInquiryScanActivityCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadInquiryScanActivityCommandWriter<S>

where S: MutStorage,

type Ok = ReadInquiryScanActivityCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadInquiryScanActivityCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadLEHostSupportCommand<S, CompleteState>

where S: Storage,

type Ok = ReadLEHostSupportCommand<S, OkState>

fn check_ok( self, ) -> Result<<ReadLEHostSupportCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadLEHostSupportCommand<S, OkState>

where S: Storage,

type Ok = ReadLEHostSupportCommand<S, OkState>

fn check_ok( self, ) -> Result<<ReadLEHostSupportCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadLEHostSupportCommand<S>

where S: Storage,

type Ok = ReadLEHostSupportCommand<S, OkState>

fn check_ok(self) -> Result<<ReadLEHostSupportCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadLEHostSupportCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = ReadLEHostSupportCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadLEHostSupportCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadLEHostSupportCommandWriter<S, OkState>

where S: MutStorage,

type Ok = ReadLEHostSupportCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadLEHostSupportCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadLEHostSupportCommandWriter<S>

where S: MutStorage,

type Ok = ReadLEHostSupportCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadLEHostSupportCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadLocalExtendedFeaturesCommand<S, CompleteState>

where S: Storage,

type Ok = ReadLocalExtendedFeaturesCommand<S, OkState>

fn check_ok( self, ) -> Result<<ReadLocalExtendedFeaturesCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadLocalExtendedFeaturesCommand<S, OkState>

where S: Storage,

type Ok = ReadLocalExtendedFeaturesCommand<S, OkState>

fn check_ok( self, ) -> Result<<ReadLocalExtendedFeaturesCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadLocalExtendedFeaturesCommand<S>

where S: Storage,

type Ok = ReadLocalExtendedFeaturesCommand<S, OkState>

fn check_ok( self, ) -> Result<<ReadLocalExtendedFeaturesCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadLocalExtendedFeaturesCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = ReadLocalExtendedFeaturesCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadLocalExtendedFeaturesCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadLocalExtendedFeaturesCommandWriter<S, OkState>

where S: MutStorage,

type Ok = ReadLocalExtendedFeaturesCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadLocalExtendedFeaturesCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadLocalExtendedFeaturesCommandWriter<S>

where S: MutStorage,

type Ok = ReadLocalExtendedFeaturesCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadLocalExtendedFeaturesCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadLocalNameCommand<S, CompleteState>

where S: Storage,

type Ok = ReadLocalNameCommand<S, OkState>

fn check_ok( self, ) -> Result<<ReadLocalNameCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadLocalNameCommand<S, OkState>

where S: Storage,

type Ok = ReadLocalNameCommand<S, OkState>

fn check_ok( self, ) -> Result<<ReadLocalNameCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadLocalNameCommand<S>

where S: Storage,

type Ok = ReadLocalNameCommand<S, OkState>

fn check_ok(self) -> Result<<ReadLocalNameCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadLocalNameCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = ReadLocalNameCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadLocalNameCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadLocalNameCommandWriter<S, OkState>

where S: MutStorage,

type Ok = ReadLocalNameCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadLocalNameCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadLocalNameCommandWriter<S>

where S: MutStorage,

type Ok = ReadLocalNameCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadLocalNameCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadLocalSupportedCommandsCommand<S, CompleteState>

where S: Storage,

type Ok = ReadLocalSupportedCommandsCommand<S, OkState>

fn check_ok( self, ) -> Result<<ReadLocalSupportedCommandsCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadLocalSupportedCommandsCommand<S, OkState>

where S: Storage,

type Ok = ReadLocalSupportedCommandsCommand<S, OkState>

fn check_ok( self, ) -> Result<<ReadLocalSupportedCommandsCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadLocalSupportedCommandsCommand<S>

where S: Storage,

type Ok = ReadLocalSupportedCommandsCommand<S, OkState>

fn check_ok( self, ) -> Result<<ReadLocalSupportedCommandsCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadLocalSupportedCommandsCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = ReadLocalSupportedCommandsCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadLocalSupportedCommandsCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadLocalSupportedCommandsCommandWriter<S, OkState>

where S: MutStorage,

type Ok = ReadLocalSupportedCommandsCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadLocalSupportedCommandsCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadLocalSupportedCommandsCommandWriter<S>

where S: MutStorage,

type Ok = ReadLocalSupportedCommandsCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadLocalSupportedCommandsCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadLocalSupportedControllerDelayCommand<S, CompleteState>

where S: Storage,

type Ok = ReadLocalSupportedControllerDelayCommand<S, OkState>

fn check_ok( self, ) -> Result<<ReadLocalSupportedControllerDelayCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadLocalSupportedControllerDelayCommand<S, OkState>

where S: Storage,

type Ok = ReadLocalSupportedControllerDelayCommand<S, OkState>

fn check_ok( self, ) -> Result<<ReadLocalSupportedControllerDelayCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadLocalSupportedControllerDelayCommand<S>

where S: Storage,

type Ok = ReadLocalSupportedControllerDelayCommand<S, OkState>

fn check_ok( self, ) -> Result<<ReadLocalSupportedControllerDelayCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadLocalSupportedControllerDelayCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = ReadLocalSupportedControllerDelayCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadLocalSupportedControllerDelayCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadLocalSupportedControllerDelayCommandWriter<S, OkState>

where S: MutStorage,

type Ok = ReadLocalSupportedControllerDelayCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadLocalSupportedControllerDelayCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadLocalSupportedControllerDelayCommandWriter<S>

where S: MutStorage,

type Ok = ReadLocalSupportedControllerDelayCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadLocalSupportedControllerDelayCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadLocalSupportedFeaturesCommand<S, CompleteState>

where S: Storage,

type Ok = ReadLocalSupportedFeaturesCommand<S, OkState>

fn check_ok( self, ) -> Result<<ReadLocalSupportedFeaturesCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadLocalSupportedFeaturesCommand<S, OkState>

where S: Storage,

type Ok = ReadLocalSupportedFeaturesCommand<S, OkState>

fn check_ok( self, ) -> Result<<ReadLocalSupportedFeaturesCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadLocalSupportedFeaturesCommand<S>

where S: Storage,

type Ok = ReadLocalSupportedFeaturesCommand<S, OkState>

fn check_ok( self, ) -> Result<<ReadLocalSupportedFeaturesCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadLocalSupportedFeaturesCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = ReadLocalSupportedFeaturesCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadLocalSupportedFeaturesCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadLocalSupportedFeaturesCommandWriter<S, OkState>

where S: MutStorage,

type Ok = ReadLocalSupportedFeaturesCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadLocalSupportedFeaturesCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadLocalSupportedFeaturesCommandWriter<S>

where S: MutStorage,

type Ok = ReadLocalSupportedFeaturesCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadLocalSupportedFeaturesCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadLocalVersionInformationCommand<S, CompleteState>

where S: Storage,

type Ok = ReadLocalVersionInformationCommand<S, OkState>

fn check_ok( self, ) -> Result<<ReadLocalVersionInformationCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadLocalVersionInformationCommand<S, OkState>

where S: Storage,

type Ok = ReadLocalVersionInformationCommand<S, OkState>

fn check_ok( self, ) -> Result<<ReadLocalVersionInformationCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadLocalVersionInformationCommand<S>

where S: Storage,

type Ok = ReadLocalVersionInformationCommand<S, OkState>

fn check_ok( self, ) -> Result<<ReadLocalVersionInformationCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadLocalVersionInformationCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = ReadLocalVersionInformationCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadLocalVersionInformationCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadLocalVersionInformationCommandWriter<S, OkState>

where S: MutStorage,

type Ok = ReadLocalVersionInformationCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadLocalVersionInformationCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadLocalVersionInformationCommandWriter<S>

where S: MutStorage,

type Ok = ReadLocalVersionInformationCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadLocalVersionInformationCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadPageScanActivityCommand<S, CompleteState>

where S: Storage,

type Ok = ReadPageScanActivityCommand<S, OkState>

fn check_ok( self, ) -> Result<<ReadPageScanActivityCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadPageScanActivityCommand<S, OkState>

where S: Storage,

type Ok = ReadPageScanActivityCommand<S, OkState>

fn check_ok( self, ) -> Result<<ReadPageScanActivityCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadPageScanActivityCommand<S>

where S: Storage,

type Ok = ReadPageScanActivityCommand<S, OkState>

fn check_ok( self, ) -> Result<<ReadPageScanActivityCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadPageScanActivityCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = ReadPageScanActivityCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadPageScanActivityCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadPageScanActivityCommandWriter<S, OkState>

where S: MutStorage,

type Ok = ReadPageScanActivityCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadPageScanActivityCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadPageScanActivityCommandWriter<S>

where S: MutStorage,

type Ok = ReadPageScanActivityCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadPageScanActivityCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadPageScanTypeCommand<S, CompleteState>

where S: Storage,

type Ok = ReadPageScanTypeCommand<S, OkState>

fn check_ok( self, ) -> Result<<ReadPageScanTypeCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadPageScanTypeCommand<S, OkState>

where S: Storage,

type Ok = ReadPageScanTypeCommand<S, OkState>

fn check_ok( self, ) -> Result<<ReadPageScanTypeCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadPageScanTypeCommand<S>

where S: Storage,

type Ok = ReadPageScanTypeCommand<S, OkState>

fn check_ok(self) -> Result<<ReadPageScanTypeCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadPageScanTypeCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = ReadPageScanTypeCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadPageScanTypeCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadPageScanTypeCommandWriter<S, OkState>

where S: MutStorage,

type Ok = ReadPageScanTypeCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadPageScanTypeCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadPageScanTypeCommandWriter<S>

where S: MutStorage,

type Ok = ReadPageScanTypeCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadPageScanTypeCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadPinTypeCommand<S, CompleteState>

where S: Storage,

type Ok = ReadPinTypeCommand<S, OkState>

fn check_ok( self, ) -> Result<<ReadPinTypeCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadPinTypeCommand<S, OkState>

where S: Storage,

type Ok = ReadPinTypeCommand<S, OkState>

fn check_ok( self, ) -> Result<<ReadPinTypeCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadPinTypeCommand<S>

where S: Storage,

type Ok = ReadPinTypeCommand<S, OkState>

fn check_ok(self) -> Result<<ReadPinTypeCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadPinTypeCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = ReadPinTypeCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadPinTypeCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadPinTypeCommandWriter<S, OkState>

where S: MutStorage,

type Ok = ReadPinTypeCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadPinTypeCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadPinTypeCommandWriter<S>

where S: MutStorage,

type Ok = ReadPinTypeCommandWriter<S, OkState>

fn check_ok(self) -> Result<<ReadPinTypeCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadRemoteExtendedFeaturesCommand<S, CompleteState>

where S: Storage,

type Ok = ReadRemoteExtendedFeaturesCommand<S, OkState>

fn check_ok( self, ) -> Result<<ReadRemoteExtendedFeaturesCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadRemoteExtendedFeaturesCommand<S, OkState>

where S: Storage,

type Ok = ReadRemoteExtendedFeaturesCommand<S, OkState>

fn check_ok( self, ) -> Result<<ReadRemoteExtendedFeaturesCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadRemoteExtendedFeaturesCommand<S>

where S: Storage,

type Ok = ReadRemoteExtendedFeaturesCommand<S, OkState>

fn check_ok( self, ) -> Result<<ReadRemoteExtendedFeaturesCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadRemoteExtendedFeaturesCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = ReadRemoteExtendedFeaturesCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadRemoteExtendedFeaturesCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadRemoteExtendedFeaturesCommandWriter<S, OkState>

where S: MutStorage,

type Ok = ReadRemoteExtendedFeaturesCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadRemoteExtendedFeaturesCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadRemoteExtendedFeaturesCommandWriter<S>

where S: MutStorage,

type Ok = ReadRemoteExtendedFeaturesCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadRemoteExtendedFeaturesCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadRemoteSupportedFeaturesCommand<S, CompleteState>

where S: Storage,

type Ok = ReadRemoteSupportedFeaturesCommand<S, OkState>

fn check_ok( self, ) -> Result<<ReadRemoteSupportedFeaturesCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadRemoteSupportedFeaturesCommand<S, OkState>

where S: Storage,

type Ok = ReadRemoteSupportedFeaturesCommand<S, OkState>

fn check_ok( self, ) -> Result<<ReadRemoteSupportedFeaturesCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadRemoteSupportedFeaturesCommand<S>

where S: Storage,

type Ok = ReadRemoteSupportedFeaturesCommand<S, OkState>

fn check_ok( self, ) -> Result<<ReadRemoteSupportedFeaturesCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadRemoteSupportedFeaturesCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = ReadRemoteSupportedFeaturesCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadRemoteSupportedFeaturesCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadRemoteSupportedFeaturesCommandWriter<S, OkState>

where S: MutStorage,

type Ok = ReadRemoteSupportedFeaturesCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadRemoteSupportedFeaturesCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadRemoteSupportedFeaturesCommandWriter<S>

where S: MutStorage,

type Ok = ReadRemoteSupportedFeaturesCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadRemoteSupportedFeaturesCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadRemoteVersionInfoCommand<S, CompleteState>

where S: Storage,

type Ok = ReadRemoteVersionInfoCommand<S, OkState>

fn check_ok( self, ) -> Result<<ReadRemoteVersionInfoCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadRemoteVersionInfoCommand<S, OkState>

where S: Storage,

type Ok = ReadRemoteVersionInfoCommand<S, OkState>

fn check_ok( self, ) -> Result<<ReadRemoteVersionInfoCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadRemoteVersionInfoCommand<S>

where S: Storage,

type Ok = ReadRemoteVersionInfoCommand<S, OkState>

fn check_ok( self, ) -> Result<<ReadRemoteVersionInfoCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadRemoteVersionInfoCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = ReadRemoteVersionInfoCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadRemoteVersionInfoCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadRemoteVersionInfoCommandWriter<S, OkState>

where S: MutStorage,

type Ok = ReadRemoteVersionInfoCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadRemoteVersionInfoCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadRemoteVersionInfoCommandWriter<S>

where S: MutStorage,

type Ok = ReadRemoteVersionInfoCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadRemoteVersionInfoCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadRssiCommand<S, CompleteState>

where S: Storage,

type Ok = ReadRssiCommand<S, OkState>

fn check_ok( self, ) -> Result<<ReadRssiCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadRssiCommand<S, OkState>

where S: Storage,

type Ok = ReadRssiCommand<S, OkState>

fn check_ok(self) -> Result<<ReadRssiCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadRssiCommand<S>

where S: Storage,

type Ok = ReadRssiCommand<S, OkState>

fn check_ok(self) -> Result<<ReadRssiCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadRssiCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = ReadRssiCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadRssiCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadRssiCommandWriter<S, OkState>

where S: MutStorage,

type Ok = ReadRssiCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadRssiCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadRssiCommandWriter<S>

where S: MutStorage,

type Ok = ReadRssiCommandWriter<S, OkState>

fn check_ok(self) -> Result<<ReadRssiCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadScanEnableCommand<S, CompleteState>

where S: Storage,

type Ok = ReadScanEnableCommand<S, OkState>

fn check_ok( self, ) -> Result<<ReadScanEnableCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadScanEnableCommand<S, OkState>

where S: Storage,

type Ok = ReadScanEnableCommand<S, OkState>

fn check_ok( self, ) -> Result<<ReadScanEnableCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadScanEnableCommand<S>

where S: Storage,

type Ok = ReadScanEnableCommand<S, OkState>

fn check_ok(self) -> Result<<ReadScanEnableCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadScanEnableCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = ReadScanEnableCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadScanEnableCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadScanEnableCommandWriter<S, OkState>

where S: MutStorage,

type Ok = ReadScanEnableCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadScanEnableCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadScanEnableCommandWriter<S>

where S: MutStorage,

type Ok = ReadScanEnableCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadScanEnableCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadSimplePairingModeCommand<S, CompleteState>

where S: Storage,

type Ok = ReadSimplePairingModeCommand<S, OkState>

fn check_ok( self, ) -> Result<<ReadSimplePairingModeCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadSimplePairingModeCommand<S, OkState>

where S: Storage,

type Ok = ReadSimplePairingModeCommand<S, OkState>

fn check_ok( self, ) -> Result<<ReadSimplePairingModeCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadSimplePairingModeCommand<S>

where S: Storage,

type Ok = ReadSimplePairingModeCommand<S, OkState>

fn check_ok( self, ) -> Result<<ReadSimplePairingModeCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadSimplePairingModeCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = ReadSimplePairingModeCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadSimplePairingModeCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadSimplePairingModeCommandWriter<S, OkState>

where S: MutStorage,

type Ok = ReadSimplePairingModeCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadSimplePairingModeCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ReadSimplePairingModeCommandWriter<S>

where S: MutStorage,

type Ok = ReadSimplePairingModeCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ReadSimplePairingModeCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for RejectConnectionRequestCommand<S, CompleteState>

where S: Storage,

type Ok = RejectConnectionRequestCommand<S, OkState>

fn check_ok( self, ) -> Result<<RejectConnectionRequestCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for RejectConnectionRequestCommand<S, OkState>

where S: Storage,

type Ok = RejectConnectionRequestCommand<S, OkState>

fn check_ok( self, ) -> Result<<RejectConnectionRequestCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for RejectConnectionRequestCommand<S>

where S: Storage,

type Ok = RejectConnectionRequestCommand<S, OkState>

fn check_ok( self, ) -> Result<<RejectConnectionRequestCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for RejectConnectionRequestCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = RejectConnectionRequestCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<RejectConnectionRequestCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for RejectConnectionRequestCommandWriter<S, OkState>

where S: MutStorage,

type Ok = RejectConnectionRequestCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<RejectConnectionRequestCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for RejectConnectionRequestCommandWriter<S>

where S: MutStorage,

type Ok = RejectConnectionRequestCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<RejectConnectionRequestCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for RejectSynchronousConnectionRequestCommand<S, CompleteState>

where S: Storage,

type Ok = RejectSynchronousConnectionRequestCommand<S, OkState>

fn check_ok( self, ) -> Result<<RejectSynchronousConnectionRequestCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for RejectSynchronousConnectionRequestCommand<S, OkState>

where S: Storage,

type Ok = RejectSynchronousConnectionRequestCommand<S, OkState>

fn check_ok( self, ) -> Result<<RejectSynchronousConnectionRequestCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for RejectSynchronousConnectionRequestCommand<S>

where S: Storage,

type Ok = RejectSynchronousConnectionRequestCommand<S, OkState>

fn check_ok( self, ) -> Result<<RejectSynchronousConnectionRequestCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for RejectSynchronousConnectionRequestCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = RejectSynchronousConnectionRequestCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<RejectSynchronousConnectionRequestCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for RejectSynchronousConnectionRequestCommandWriter<S, OkState>

where S: MutStorage,

type Ok = RejectSynchronousConnectionRequestCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<RejectSynchronousConnectionRequestCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for RejectSynchronousConnectionRequestCommandWriter<S>

where S: MutStorage,

type Ok = RejectSynchronousConnectionRequestCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<RejectSynchronousConnectionRequestCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for RemoteNameRequestCommand<S, CompleteState>

where S: Storage,

type Ok = RemoteNameRequestCommand<S, OkState>

fn check_ok( self, ) -> Result<<RemoteNameRequestCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for RemoteNameRequestCommand<S, OkState>

where S: Storage,

type Ok = RemoteNameRequestCommand<S, OkState>

fn check_ok( self, ) -> Result<<RemoteNameRequestCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for RemoteNameRequestCommand<S>

where S: Storage,

type Ok = RemoteNameRequestCommand<S, OkState>

fn check_ok(self) -> Result<<RemoteNameRequestCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for RemoteNameRequestCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = RemoteNameRequestCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<RemoteNameRequestCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for RemoteNameRequestCommandWriter<S, OkState>

where S: MutStorage,

type Ok = RemoteNameRequestCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<RemoteNameRequestCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for RemoteNameRequestCommandWriter<S>

where S: MutStorage,

type Ok = RemoteNameRequestCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<RemoteNameRequestCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ResetCommand<S, CompleteState>

where S: Storage,

type Ok = ResetCommand<S, OkState>

fn check_ok( self, ) -> Result<<ResetCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ResetCommand<S, OkState>

where S: Storage,

type Ok = ResetCommand<S, OkState>

fn check_ok(self) -> Result<<ResetCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ResetCommand<S>

where S: Storage,

type Ok = ResetCommand<S, OkState>

fn check_ok(self) -> Result<<ResetCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ResetCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = ResetCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ResetCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ResetCommandWriter<S, OkState>

where S: MutStorage,

type Ok = ResetCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<ResetCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ResetCommandWriter<S>

where S: MutStorage,

type Ok = ResetCommandWriter<S, OkState>

fn check_ok(self) -> Result<<ResetCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ScanEnableBits<S, CompleteState>

where S: Storage,

type Ok = ScanEnableBits<S, OkState>

fn check_ok( self, ) -> Result<<ScanEnableBits<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ScanEnableBits<S, OkState>

where S: Storage,

type Ok = ScanEnableBits<S, OkState>

fn check_ok(self) -> Result<<ScanEnableBits<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ScanEnableBits<S>

where S: Storage,

type Ok = ScanEnableBits<S, OkState>

fn check_ok(self) -> Result<<ScanEnableBits<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ScanEnableBitsWriter<S, CompleteState>

where S: MutStorage,

type Ok = ScanEnableBitsWriter<S, OkState>

fn check_ok( self, ) -> Result<<ScanEnableBitsWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ScanEnableBitsWriter<S, OkState>

where S: MutStorage,

type Ok = ScanEnableBitsWriter<S, OkState>

fn check_ok( self, ) -> Result<<ScanEnableBitsWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ScanEnableBitsWriter<S>

where S: MutStorage,

type Ok = ScanEnableBitsWriter<S, OkState>

fn check_ok(self) -> Result<<ScanEnableBitsWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ScoDataHeader<S, CompleteState>

where S: Storage,

type Ok = ScoDataHeader<S, OkState>

fn check_ok( self, ) -> Result<<ScoDataHeader<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ScoDataHeader<S, OkState>

where S: Storage,

type Ok = ScoDataHeader<S, OkState>

fn check_ok(self) -> Result<<ScoDataHeader<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ScoDataHeader<S>

where S: Storage,

type Ok = ScoDataHeader<S, OkState>

fn check_ok(self) -> Result<<ScoDataHeader<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ScoDataHeaderWriter<S, CompleteState>

where S: MutStorage,

type Ok = ScoDataHeaderWriter<S, OkState>

fn check_ok( self, ) -> Result<<ScoDataHeaderWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ScoDataHeaderWriter<S, OkState>

where S: MutStorage,

type Ok = ScoDataHeaderWriter<S, OkState>

fn check_ok( self, ) -> Result<<ScoDataHeaderWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ScoDataHeaderWriter<S>

where S: MutStorage,

type Ok = ScoDataHeaderWriter<S, OkState>

fn check_ok(self) -> Result<<ScoDataHeaderWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ScoDataHeader_EmbossReservedAnonymousField1<S, CompleteState>

where S: Storage,

type Ok = ScoDataHeader_EmbossReservedAnonymousField1<S, OkState>

fn check_ok( self, ) -> Result<<ScoDataHeader_EmbossReservedAnonymousField1<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ScoDataHeader_EmbossReservedAnonymousField1<S, OkState>

where S: Storage,

type Ok = ScoDataHeader_EmbossReservedAnonymousField1<S, OkState>

fn check_ok( self, ) -> Result<<ScoDataHeader_EmbossReservedAnonymousField1<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ScoDataHeader_EmbossReservedAnonymousField1<S>

where S: Storage,

type Ok = ScoDataHeader_EmbossReservedAnonymousField1<S, OkState>

fn check_ok( self, ) -> Result<<ScoDataHeader_EmbossReservedAnonymousField1<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ScoDataHeader_EmbossReservedAnonymousField1Writer<S, CompleteState>

where S: MutStorage,

type Ok = ScoDataHeader_EmbossReservedAnonymousField1Writer<S, OkState>

fn check_ok( self, ) -> Result<<ScoDataHeader_EmbossReservedAnonymousField1Writer<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ScoDataHeader_EmbossReservedAnonymousField1Writer<S, OkState>

where S: MutStorage,

type Ok = ScoDataHeader_EmbossReservedAnonymousField1Writer<S, OkState>

fn check_ok( self, ) -> Result<<ScoDataHeader_EmbossReservedAnonymousField1Writer<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ScoDataHeader_EmbossReservedAnonymousField1Writer<S>

where S: MutStorage,

type Ok = ScoDataHeader_EmbossReservedAnonymousField1Writer<S, OkState>

fn check_ok( self, ) -> Result<<ScoDataHeader_EmbossReservedAnonymousField1Writer<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ScoPacketType<S, CompleteState>

where S: Storage,

type Ok = ScoPacketType<S, OkState>

fn check_ok( self, ) -> Result<<ScoPacketType<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ScoPacketType<S, OkState>

where S: Storage,

type Ok = ScoPacketType<S, OkState>

fn check_ok(self) -> Result<<ScoPacketType<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ScoPacketType<S>

where S: Storage,

type Ok = ScoPacketType<S, OkState>

fn check_ok(self) -> Result<<ScoPacketType<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for ScoPacketTypeWriter<S, CompleteState>

where S: MutStorage,

type Ok = ScoPacketTypeWriter<S, OkState>

fn check_ok( self, ) -> Result<<ScoPacketTypeWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ScoPacketTypeWriter<S, OkState>

where S: MutStorage,

type Ok = ScoPacketTypeWriter<S, OkState>

fn check_ok( self, ) -> Result<<ScoPacketTypeWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for ScoPacketTypeWriter<S>

where S: MutStorage,

type Ok = ScoPacketTypeWriter<S, OkState>

fn check_ok(self) -> Result<<ScoPacketTypeWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for SetConnectionEncryptionCommand<S, CompleteState>

where S: Storage,

type Ok = SetConnectionEncryptionCommand<S, OkState>

fn check_ok( self, ) -> Result<<SetConnectionEncryptionCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for SetConnectionEncryptionCommand<S, OkState>

where S: Storage,

type Ok = SetConnectionEncryptionCommand<S, OkState>

fn check_ok( self, ) -> Result<<SetConnectionEncryptionCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for SetConnectionEncryptionCommand<S>

where S: Storage,

type Ok = SetConnectionEncryptionCommand<S, OkState>

fn check_ok( self, ) -> Result<<SetConnectionEncryptionCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for SetConnectionEncryptionCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = SetConnectionEncryptionCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<SetConnectionEncryptionCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for SetConnectionEncryptionCommandWriter<S, OkState>

where S: MutStorage,

type Ok = SetConnectionEncryptionCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<SetConnectionEncryptionCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for SetConnectionEncryptionCommandWriter<S>

where S: MutStorage,

type Ok = SetConnectionEncryptionCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<SetConnectionEncryptionCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for SetEventMaskCommand<S, CompleteState>

where S: Storage,

type Ok = SetEventMaskCommand<S, OkState>

fn check_ok( self, ) -> Result<<SetEventMaskCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for SetEventMaskCommand<S, OkState>

where S: Storage,

type Ok = SetEventMaskCommand<S, OkState>

fn check_ok( self, ) -> Result<<SetEventMaskCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for SetEventMaskCommand<S>

where S: Storage,

type Ok = SetEventMaskCommand<S, OkState>

fn check_ok(self) -> Result<<SetEventMaskCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for SetEventMaskCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = SetEventMaskCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<SetEventMaskCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for SetEventMaskCommandWriter<S, OkState>

where S: MutStorage,

type Ok = SetEventMaskCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<SetEventMaskCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for SetEventMaskCommandWriter<S>

where S: MutStorage,

type Ok = SetEventMaskCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<SetEventMaskCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for SetEventMaskCommand_EmbossReservedAnonymousField13<S, CompleteState>

where S: Storage,

type Ok = SetEventMaskCommand_EmbossReservedAnonymousField13<S, OkState>

fn check_ok( self, ) -> Result<<SetEventMaskCommand_EmbossReservedAnonymousField13<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for SetEventMaskCommand_EmbossReservedAnonymousField13<S, OkState>

where S: Storage,

type Ok = SetEventMaskCommand_EmbossReservedAnonymousField13<S, OkState>

fn check_ok( self, ) -> Result<<SetEventMaskCommand_EmbossReservedAnonymousField13<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for SetEventMaskCommand_EmbossReservedAnonymousField13<S>

where S: Storage,

type Ok = SetEventMaskCommand_EmbossReservedAnonymousField13<S, OkState>

fn check_ok( self, ) -> Result<<SetEventMaskCommand_EmbossReservedAnonymousField13<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for SetEventMaskCommand_EmbossReservedAnonymousField13Writer<S, CompleteState>

where S: MutStorage,

type Ok = SetEventMaskCommand_EmbossReservedAnonymousField13Writer<S, OkState>

fn check_ok( self, ) -> Result<<SetEventMaskCommand_EmbossReservedAnonymousField13Writer<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for SetEventMaskCommand_EmbossReservedAnonymousField13Writer<S, OkState>

where S: MutStorage,

type Ok = SetEventMaskCommand_EmbossReservedAnonymousField13Writer<S, OkState>

fn check_ok( self, ) -> Result<<SetEventMaskCommand_EmbossReservedAnonymousField13Writer<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for SetEventMaskCommand_EmbossReservedAnonymousField13Writer<S>

where S: MutStorage,

type Ok = SetEventMaskCommand_EmbossReservedAnonymousField13Writer<S, OkState>

fn check_ok( self, ) -> Result<<SetEventMaskCommand_EmbossReservedAnonymousField13Writer<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for SetEventMaskPage2Command<S, CompleteState>

where S: Storage,

type Ok = SetEventMaskPage2Command<S, OkState>

fn check_ok( self, ) -> Result<<SetEventMaskPage2Command<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for SetEventMaskPage2Command<S, OkState>

where S: Storage,

type Ok = SetEventMaskPage2Command<S, OkState>

fn check_ok( self, ) -> Result<<SetEventMaskPage2Command<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for SetEventMaskPage2Command<S>

where S: Storage,

type Ok = SetEventMaskPage2Command<S, OkState>

fn check_ok(self) -> Result<<SetEventMaskPage2Command<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for SetEventMaskPage2CommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = SetEventMaskPage2CommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<SetEventMaskPage2CommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for SetEventMaskPage2CommandWriter<S, OkState>

where S: MutStorage,

type Ok = SetEventMaskPage2CommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<SetEventMaskPage2CommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for SetEventMaskPage2CommandWriter<S>

where S: MutStorage,

type Ok = SetEventMaskPage2CommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<SetEventMaskPage2CommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for SetEventMaskPage2Command_EmbossReservedAnonymousField11<S, CompleteState>

where S: Storage,

type Ok = SetEventMaskPage2Command_EmbossReservedAnonymousField11<S, OkState>

fn check_ok( self, ) -> Result<<SetEventMaskPage2Command_EmbossReservedAnonymousField11<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for SetEventMaskPage2Command_EmbossReservedAnonymousField11<S, OkState>

where S: Storage,

type Ok = SetEventMaskPage2Command_EmbossReservedAnonymousField11<S, OkState>

fn check_ok( self, ) -> Result<<SetEventMaskPage2Command_EmbossReservedAnonymousField11<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for SetEventMaskPage2Command_EmbossReservedAnonymousField11<S>

where S: Storage,

type Ok = SetEventMaskPage2Command_EmbossReservedAnonymousField11<S, OkState>

fn check_ok( self, ) -> Result<<SetEventMaskPage2Command_EmbossReservedAnonymousField11<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for SetEventMaskPage2Command_EmbossReservedAnonymousField11Writer<S, CompleteState>

where S: MutStorage,

type Ok = SetEventMaskPage2Command_EmbossReservedAnonymousField11Writer<S, OkState>

fn check_ok( self, ) -> Result<<SetEventMaskPage2Command_EmbossReservedAnonymousField11Writer<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for SetEventMaskPage2Command_EmbossReservedAnonymousField11Writer<S, OkState>

where S: MutStorage,

type Ok = SetEventMaskPage2Command_EmbossReservedAnonymousField11Writer<S, OkState>

fn check_ok( self, ) -> Result<<SetEventMaskPage2Command_EmbossReservedAnonymousField11Writer<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for SetEventMaskPage2Command_EmbossReservedAnonymousField11Writer<S>

where S: MutStorage,

type Ok = SetEventMaskPage2Command_EmbossReservedAnonymousField11Writer<S, OkState>

fn check_ok( self, ) -> Result<<SetEventMaskPage2Command_EmbossReservedAnonymousField11Writer<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for SniffModeCommand<S, CompleteState>

where S: Storage,

type Ok = SniffModeCommand<S, OkState>

fn check_ok( self, ) -> Result<<SniffModeCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for SniffModeCommand<S, OkState>

where S: Storage,

type Ok = SniffModeCommand<S, OkState>

fn check_ok( self, ) -> Result<<SniffModeCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for SniffModeCommand<S>

where S: Storage,

type Ok = SniffModeCommand<S, OkState>

fn check_ok(self) -> Result<<SniffModeCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for SniffModeCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = SniffModeCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<SniffModeCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for SniffModeCommandWriter<S, OkState>

where S: MutStorage,

type Ok = SniffModeCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<SniffModeCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for SniffModeCommandWriter<S>

where S: MutStorage,

type Ok = SniffModeCommandWriter<S, OkState>

fn check_ok(self) -> Result<<SniffModeCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for SniffSubratingCommand<S, CompleteState>

where S: Storage,

type Ok = SniffSubratingCommand<S, OkState>

fn check_ok( self, ) -> Result<<SniffSubratingCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for SniffSubratingCommand<S, OkState>

where S: Storage,

type Ok = SniffSubratingCommand<S, OkState>

fn check_ok( self, ) -> Result<<SniffSubratingCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for SniffSubratingCommand<S>

where S: Storage,

type Ok = SniffSubratingCommand<S, OkState>

fn check_ok(self) -> Result<<SniffSubratingCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for SniffSubratingCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = SniffSubratingCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<SniffSubratingCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for SniffSubratingCommandWriter<S, OkState>

where S: MutStorage,

type Ok = SniffSubratingCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<SniffSubratingCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for SniffSubratingCommandWriter<S>

where S: MutStorage,

type Ok = SniffSubratingCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<SniffSubratingCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for SubsequentKFrame<S, CompleteState>

where S: Storage,

type Ok = SubsequentKFrame<S, OkState>

fn check_ok( self, ) -> Result<<SubsequentKFrame<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for SubsequentKFrame<S, OkState>

where S: Storage,

type Ok = SubsequentKFrame<S, OkState>

fn check_ok( self, ) -> Result<<SubsequentKFrame<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for SubsequentKFrame<S>

where S: Storage,

type Ok = SubsequentKFrame<S, OkState>

fn check_ok(self) -> Result<<SubsequentKFrame<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for SubsequentKFrameWriter<S, CompleteState>

where S: MutStorage,

type Ok = SubsequentKFrameWriter<S, OkState>

fn check_ok( self, ) -> Result<<SubsequentKFrameWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for SubsequentKFrameWriter<S, OkState>

where S: MutStorage,

type Ok = SubsequentKFrameWriter<S, OkState>

fn check_ok( self, ) -> Result<<SubsequentKFrameWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for SubsequentKFrameWriter<S>

where S: MutStorage,

type Ok = SubsequentKFrameWriter<S, OkState>

fn check_ok(self) -> Result<<SubsequentKFrameWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for SynchronousConnectionParameters<S, CompleteState>

where S: Storage,

type Ok = SynchronousConnectionParameters<S, OkState>

fn check_ok( self, ) -> Result<<SynchronousConnectionParameters<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for SynchronousConnectionParameters<S, OkState>

where S: Storage,

type Ok = SynchronousConnectionParameters<S, OkState>

fn check_ok( self, ) -> Result<<SynchronousConnectionParameters<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for SynchronousConnectionParameters<S>

where S: Storage,

type Ok = SynchronousConnectionParameters<S, OkState>

fn check_ok( self, ) -> Result<<SynchronousConnectionParameters<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for SynchronousConnectionParametersWriter<S, CompleteState>

where S: MutStorage,

type Ok = SynchronousConnectionParametersWriter<S, OkState>

fn check_ok( self, ) -> Result<<SynchronousConnectionParametersWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for SynchronousConnectionParametersWriter<S, OkState>

where S: MutStorage,

type Ok = SynchronousConnectionParametersWriter<S, OkState>

fn check_ok( self, ) -> Result<<SynchronousConnectionParametersWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for SynchronousConnectionParametersWriter<S>

where S: MutStorage,

type Ok = SynchronousConnectionParametersWriter<S, OkState>

fn check_ok( self, ) -> Result<<SynchronousConnectionParametersWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for SynchronousConnectionParameters_EmbossReservedAnonymousField15<S, CompleteState>

where S: Storage,

type Ok = SynchronousConnectionParameters_EmbossReservedAnonymousField15<S, OkState>

fn check_ok( self, ) -> Result<<SynchronousConnectionParameters_EmbossReservedAnonymousField15<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for SynchronousConnectionParameters_EmbossReservedAnonymousField15<S, OkState>

where S: Storage,

type Ok = SynchronousConnectionParameters_EmbossReservedAnonymousField15<S, OkState>

fn check_ok( self, ) -> Result<<SynchronousConnectionParameters_EmbossReservedAnonymousField15<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for SynchronousConnectionParameters_EmbossReservedAnonymousField15<S>

where S: Storage,

type Ok = SynchronousConnectionParameters_EmbossReservedAnonymousField15<S, OkState>

fn check_ok( self, ) -> Result<<SynchronousConnectionParameters_EmbossReservedAnonymousField15<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for SynchronousConnectionParameters_EmbossReservedAnonymousField15Writer<S, CompleteState>

where S: MutStorage,

type Ok = SynchronousConnectionParameters_EmbossReservedAnonymousField15Writer<S, OkState>

fn check_ok( self, ) -> Result<<SynchronousConnectionParameters_EmbossReservedAnonymousField15Writer<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for SynchronousConnectionParameters_EmbossReservedAnonymousField15Writer<S, OkState>

where S: MutStorage,

type Ok = SynchronousConnectionParameters_EmbossReservedAnonymousField15Writer<S, OkState>

fn check_ok( self, ) -> Result<<SynchronousConnectionParameters_EmbossReservedAnonymousField15Writer<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for SynchronousConnectionParameters_EmbossReservedAnonymousField15Writer<S>

where S: MutStorage,

type Ok = SynchronousConnectionParameters_EmbossReservedAnonymousField15Writer<S, OkState>

fn check_ok( self, ) -> Result<<SynchronousConnectionParameters_EmbossReservedAnonymousField15Writer<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for SynchronousConnectionParameters_VendorCodingFormat<S, CompleteState>

where S: Storage,

type Ok = SynchronousConnectionParameters_VendorCodingFormat<S, OkState>

fn check_ok( self, ) -> Result<<SynchronousConnectionParameters_VendorCodingFormat<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for SynchronousConnectionParameters_VendorCodingFormat<S, OkState>

where S: Storage,

type Ok = SynchronousConnectionParameters_VendorCodingFormat<S, OkState>

fn check_ok( self, ) -> Result<<SynchronousConnectionParameters_VendorCodingFormat<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for SynchronousConnectionParameters_VendorCodingFormat<S>

where S: Storage,

type Ok = SynchronousConnectionParameters_VendorCodingFormat<S, OkState>

fn check_ok( self, ) -> Result<<SynchronousConnectionParameters_VendorCodingFormat<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for SynchronousConnectionParameters_VendorCodingFormatWriter<S, CompleteState>

where S: MutStorage,

type Ok = SynchronousConnectionParameters_VendorCodingFormatWriter<S, OkState>

fn check_ok( self, ) -> Result<<SynchronousConnectionParameters_VendorCodingFormatWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for SynchronousConnectionParameters_VendorCodingFormatWriter<S, OkState>

where S: MutStorage,

type Ok = SynchronousConnectionParameters_VendorCodingFormatWriter<S, OkState>

fn check_ok( self, ) -> Result<<SynchronousConnectionParameters_VendorCodingFormatWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for SynchronousConnectionParameters_VendorCodingFormatWriter<S>

where S: MutStorage,

type Ok = SynchronousConnectionParameters_VendorCodingFormatWriter<S, OkState>

fn check_ok( self, ) -> Result<<SynchronousConnectionParameters_VendorCodingFormatWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for UserConfirmationRequestNegativeReplyCommand<S, CompleteState>

where S: Storage,

type Ok = UserConfirmationRequestNegativeReplyCommand<S, OkState>

fn check_ok( self, ) -> Result<<UserConfirmationRequestNegativeReplyCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for UserConfirmationRequestNegativeReplyCommand<S, OkState>

where S: Storage,

type Ok = UserConfirmationRequestNegativeReplyCommand<S, OkState>

fn check_ok( self, ) -> Result<<UserConfirmationRequestNegativeReplyCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for UserConfirmationRequestNegativeReplyCommand<S>

where S: Storage,

type Ok = UserConfirmationRequestNegativeReplyCommand<S, OkState>

fn check_ok( self, ) -> Result<<UserConfirmationRequestNegativeReplyCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for UserConfirmationRequestNegativeReplyCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = UserConfirmationRequestNegativeReplyCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<UserConfirmationRequestNegativeReplyCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for UserConfirmationRequestNegativeReplyCommandWriter<S, OkState>

where S: MutStorage,

type Ok = UserConfirmationRequestNegativeReplyCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<UserConfirmationRequestNegativeReplyCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for UserConfirmationRequestNegativeReplyCommandWriter<S>

where S: MutStorage,

type Ok = UserConfirmationRequestNegativeReplyCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<UserConfirmationRequestNegativeReplyCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for UserConfirmationRequestReplyCommand<S, CompleteState>

where S: Storage,

type Ok = UserConfirmationRequestReplyCommand<S, OkState>

fn check_ok( self, ) -> Result<<UserConfirmationRequestReplyCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for UserConfirmationRequestReplyCommand<S, OkState>

where S: Storage,

type Ok = UserConfirmationRequestReplyCommand<S, OkState>

fn check_ok( self, ) -> Result<<UserConfirmationRequestReplyCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for UserConfirmationRequestReplyCommand<S>

where S: Storage,

type Ok = UserConfirmationRequestReplyCommand<S, OkState>

fn check_ok( self, ) -> Result<<UserConfirmationRequestReplyCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for UserConfirmationRequestReplyCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = UserConfirmationRequestReplyCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<UserConfirmationRequestReplyCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for UserConfirmationRequestReplyCommandWriter<S, OkState>

where S: MutStorage,

type Ok = UserConfirmationRequestReplyCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<UserConfirmationRequestReplyCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for UserConfirmationRequestReplyCommandWriter<S>

where S: MutStorage,

type Ok = UserConfirmationRequestReplyCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<UserConfirmationRequestReplyCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for UserPasskeyRequestNegativeReplyCommand<S, CompleteState>

where S: Storage,

type Ok = UserPasskeyRequestNegativeReplyCommand<S, OkState>

fn check_ok( self, ) -> Result<<UserPasskeyRequestNegativeReplyCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for UserPasskeyRequestNegativeReplyCommand<S, OkState>

where S: Storage,

type Ok = UserPasskeyRequestNegativeReplyCommand<S, OkState>

fn check_ok( self, ) -> Result<<UserPasskeyRequestNegativeReplyCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for UserPasskeyRequestNegativeReplyCommand<S>

where S: Storage,

type Ok = UserPasskeyRequestNegativeReplyCommand<S, OkState>

fn check_ok( self, ) -> Result<<UserPasskeyRequestNegativeReplyCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for UserPasskeyRequestNegativeReplyCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = UserPasskeyRequestNegativeReplyCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<UserPasskeyRequestNegativeReplyCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for UserPasskeyRequestNegativeReplyCommandWriter<S, OkState>

where S: MutStorage,

type Ok = UserPasskeyRequestNegativeReplyCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<UserPasskeyRequestNegativeReplyCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for UserPasskeyRequestNegativeReplyCommandWriter<S>

where S: MutStorage,

type Ok = UserPasskeyRequestNegativeReplyCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<UserPasskeyRequestNegativeReplyCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for UserPasskeyRequestReplyCommand<S, CompleteState>

where S: Storage,

type Ok = UserPasskeyRequestReplyCommand<S, OkState>

fn check_ok( self, ) -> Result<<UserPasskeyRequestReplyCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for UserPasskeyRequestReplyCommand<S, OkState>

where S: Storage,

type Ok = UserPasskeyRequestReplyCommand<S, OkState>

fn check_ok( self, ) -> Result<<UserPasskeyRequestReplyCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for UserPasskeyRequestReplyCommand<S>

where S: Storage,

type Ok = UserPasskeyRequestReplyCommand<S, OkState>

fn check_ok( self, ) -> Result<<UserPasskeyRequestReplyCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for UserPasskeyRequestReplyCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = UserPasskeyRequestReplyCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<UserPasskeyRequestReplyCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for UserPasskeyRequestReplyCommandWriter<S, OkState>

where S: MutStorage,

type Ok = UserPasskeyRequestReplyCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<UserPasskeyRequestReplyCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for UserPasskeyRequestReplyCommandWriter<S>

where S: MutStorage,

type Ok = UserPasskeyRequestReplyCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<UserPasskeyRequestReplyCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for VendorDebugEvent<S, CompleteState>

where S: Storage,

type Ok = VendorDebugEvent<S, OkState>

fn check_ok( self, ) -> Result<<VendorDebugEvent<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for VendorDebugEvent<S, OkState>

where S: Storage,

type Ok = VendorDebugEvent<S, OkState>

fn check_ok( self, ) -> Result<<VendorDebugEvent<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for VendorDebugEvent<S>

where S: Storage,

type Ok = VendorDebugEvent<S, OkState>

fn check_ok(self) -> Result<<VendorDebugEvent<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for VendorDebugEventWriter<S, CompleteState>

where S: MutStorage,

type Ok = VendorDebugEventWriter<S, OkState>

fn check_ok( self, ) -> Result<<VendorDebugEventWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for VendorDebugEventWriter<S, OkState>

where S: MutStorage,

type Ok = VendorDebugEventWriter<S, OkState>

fn check_ok( self, ) -> Result<<VendorDebugEventWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for VendorDebugEventWriter<S>

where S: MutStorage,

type Ok = VendorDebugEventWriter<S, OkState>

fn check_ok(self) -> Result<<VendorDebugEventWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteAuthenticatedPayloadTimeoutCommand<S, CompleteState>

where S: Storage,

type Ok = WriteAuthenticatedPayloadTimeoutCommand<S, OkState>

fn check_ok( self, ) -> Result<<WriteAuthenticatedPayloadTimeoutCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteAuthenticatedPayloadTimeoutCommand<S, OkState>

where S: Storage,

type Ok = WriteAuthenticatedPayloadTimeoutCommand<S, OkState>

fn check_ok( self, ) -> Result<<WriteAuthenticatedPayloadTimeoutCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteAuthenticatedPayloadTimeoutCommand<S>

where S: Storage,

type Ok = WriteAuthenticatedPayloadTimeoutCommand<S, OkState>

fn check_ok( self, ) -> Result<<WriteAuthenticatedPayloadTimeoutCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteAuthenticatedPayloadTimeoutCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = WriteAuthenticatedPayloadTimeoutCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<WriteAuthenticatedPayloadTimeoutCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteAuthenticatedPayloadTimeoutCommandWriter<S, OkState>

where S: MutStorage,

type Ok = WriteAuthenticatedPayloadTimeoutCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<WriteAuthenticatedPayloadTimeoutCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteAuthenticatedPayloadTimeoutCommandWriter<S>

where S: MutStorage,

type Ok = WriteAuthenticatedPayloadTimeoutCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<WriteAuthenticatedPayloadTimeoutCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteAutomaticFlushTimeoutCommand<S, CompleteState>

where S: Storage,

type Ok = WriteAutomaticFlushTimeoutCommand<S, OkState>

fn check_ok( self, ) -> Result<<WriteAutomaticFlushTimeoutCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteAutomaticFlushTimeoutCommand<S, OkState>

where S: Storage,

type Ok = WriteAutomaticFlushTimeoutCommand<S, OkState>

fn check_ok( self, ) -> Result<<WriteAutomaticFlushTimeoutCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteAutomaticFlushTimeoutCommand<S>

where S: Storage,

type Ok = WriteAutomaticFlushTimeoutCommand<S, OkState>

fn check_ok( self, ) -> Result<<WriteAutomaticFlushTimeoutCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteAutomaticFlushTimeoutCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = WriteAutomaticFlushTimeoutCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<WriteAutomaticFlushTimeoutCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteAutomaticFlushTimeoutCommandWriter<S, OkState>

where S: MutStorage,

type Ok = WriteAutomaticFlushTimeoutCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<WriteAutomaticFlushTimeoutCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteAutomaticFlushTimeoutCommandWriter<S>

where S: MutStorage,

type Ok = WriteAutomaticFlushTimeoutCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<WriteAutomaticFlushTimeoutCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteClassOfDeviceCommand<S, CompleteState>

where S: Storage,

type Ok = WriteClassOfDeviceCommand<S, OkState>

fn check_ok( self, ) -> Result<<WriteClassOfDeviceCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteClassOfDeviceCommand<S, OkState>

where S: Storage,

type Ok = WriteClassOfDeviceCommand<S, OkState>

fn check_ok( self, ) -> Result<<WriteClassOfDeviceCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteClassOfDeviceCommand<S>

where S: Storage,

type Ok = WriteClassOfDeviceCommand<S, OkState>

fn check_ok( self, ) -> Result<<WriteClassOfDeviceCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteClassOfDeviceCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = WriteClassOfDeviceCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<WriteClassOfDeviceCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteClassOfDeviceCommandWriter<S, OkState>

where S: MutStorage,

type Ok = WriteClassOfDeviceCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<WriteClassOfDeviceCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteClassOfDeviceCommandWriter<S>

where S: MutStorage,

type Ok = WriteClassOfDeviceCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<WriteClassOfDeviceCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteDefaultLinkPolicySettingsCommand<S, CompleteState>

where S: Storage,

type Ok = WriteDefaultLinkPolicySettingsCommand<S, OkState>

fn check_ok( self, ) -> Result<<WriteDefaultLinkPolicySettingsCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteDefaultLinkPolicySettingsCommand<S, OkState>

where S: Storage,

type Ok = WriteDefaultLinkPolicySettingsCommand<S, OkState>

fn check_ok( self, ) -> Result<<WriteDefaultLinkPolicySettingsCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteDefaultLinkPolicySettingsCommand<S>

where S: Storage,

type Ok = WriteDefaultLinkPolicySettingsCommand<S, OkState>

fn check_ok( self, ) -> Result<<WriteDefaultLinkPolicySettingsCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteDefaultLinkPolicySettingsCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = WriteDefaultLinkPolicySettingsCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<WriteDefaultLinkPolicySettingsCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteDefaultLinkPolicySettingsCommandWriter<S, OkState>

where S: MutStorage,

type Ok = WriteDefaultLinkPolicySettingsCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<WriteDefaultLinkPolicySettingsCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteDefaultLinkPolicySettingsCommandWriter<S>

where S: MutStorage,

type Ok = WriteDefaultLinkPolicySettingsCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<WriteDefaultLinkPolicySettingsCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteDefaultLinkPolicySettingsCommand_EmbossReservedAnonymousField14<S, CompleteState>

where S: Storage,

type Ok = WriteDefaultLinkPolicySettingsCommand_EmbossReservedAnonymousField14<S, OkState>

fn check_ok( self, ) -> Result<<WriteDefaultLinkPolicySettingsCommand_EmbossReservedAnonymousField14<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteDefaultLinkPolicySettingsCommand_EmbossReservedAnonymousField14<S, OkState>

where S: Storage,

type Ok = WriteDefaultLinkPolicySettingsCommand_EmbossReservedAnonymousField14<S, OkState>

fn check_ok( self, ) -> Result<<WriteDefaultLinkPolicySettingsCommand_EmbossReservedAnonymousField14<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteDefaultLinkPolicySettingsCommand_EmbossReservedAnonymousField14<S>

where S: Storage,

type Ok = WriteDefaultLinkPolicySettingsCommand_EmbossReservedAnonymousField14<S, OkState>

fn check_ok( self, ) -> Result<<WriteDefaultLinkPolicySettingsCommand_EmbossReservedAnonymousField14<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteDefaultLinkPolicySettingsCommand_EmbossReservedAnonymousField14Writer<S, CompleteState>

where S: MutStorage,

type Ok = WriteDefaultLinkPolicySettingsCommand_EmbossReservedAnonymousField14Writer<S, OkState>

fn check_ok( self, ) -> Result<<WriteDefaultLinkPolicySettingsCommand_EmbossReservedAnonymousField14Writer<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteDefaultLinkPolicySettingsCommand_EmbossReservedAnonymousField14Writer<S, OkState>

where S: MutStorage,

type Ok = WriteDefaultLinkPolicySettingsCommand_EmbossReservedAnonymousField14Writer<S, OkState>

fn check_ok( self, ) -> Result<<WriteDefaultLinkPolicySettingsCommand_EmbossReservedAnonymousField14Writer<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteDefaultLinkPolicySettingsCommand_EmbossReservedAnonymousField14Writer<S>

where S: MutStorage,

type Ok = WriteDefaultLinkPolicySettingsCommand_EmbossReservedAnonymousField14Writer<S, OkState>

fn check_ok( self, ) -> Result<<WriteDefaultLinkPolicySettingsCommand_EmbossReservedAnonymousField14Writer<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteExtendedInquiryResponseCommand<S, CompleteState>

where S: Storage,

type Ok = WriteExtendedInquiryResponseCommand<S, OkState>

fn check_ok( self, ) -> Result<<WriteExtendedInquiryResponseCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteExtendedInquiryResponseCommand<S, OkState>

where S: Storage,

type Ok = WriteExtendedInquiryResponseCommand<S, OkState>

fn check_ok( self, ) -> Result<<WriteExtendedInquiryResponseCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteExtendedInquiryResponseCommand<S>

where S: Storage,

type Ok = WriteExtendedInquiryResponseCommand<S, OkState>

fn check_ok( self, ) -> Result<<WriteExtendedInquiryResponseCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteExtendedInquiryResponseCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = WriteExtendedInquiryResponseCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<WriteExtendedInquiryResponseCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteExtendedInquiryResponseCommandWriter<S, OkState>

where S: MutStorage,

type Ok = WriteExtendedInquiryResponseCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<WriteExtendedInquiryResponseCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteExtendedInquiryResponseCommandWriter<S>

where S: MutStorage,

type Ok = WriteExtendedInquiryResponseCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<WriteExtendedInquiryResponseCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteFlowControlModeCommand<S, CompleteState>

where S: Storage,

type Ok = WriteFlowControlModeCommand<S, OkState>

fn check_ok( self, ) -> Result<<WriteFlowControlModeCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteFlowControlModeCommand<S, OkState>

where S: Storage,

type Ok = WriteFlowControlModeCommand<S, OkState>

fn check_ok( self, ) -> Result<<WriteFlowControlModeCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteFlowControlModeCommand<S>

where S: Storage,

type Ok = WriteFlowControlModeCommand<S, OkState>

fn check_ok( self, ) -> Result<<WriteFlowControlModeCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteFlowControlModeCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = WriteFlowControlModeCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<WriteFlowControlModeCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteFlowControlModeCommandWriter<S, OkState>

where S: MutStorage,

type Ok = WriteFlowControlModeCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<WriteFlowControlModeCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteFlowControlModeCommandWriter<S>

where S: MutStorage,

type Ok = WriteFlowControlModeCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<WriteFlowControlModeCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteInquiryModeCommand<S, CompleteState>

where S: Storage,

type Ok = WriteInquiryModeCommand<S, OkState>

fn check_ok( self, ) -> Result<<WriteInquiryModeCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteInquiryModeCommand<S, OkState>

where S: Storage,

type Ok = WriteInquiryModeCommand<S, OkState>

fn check_ok( self, ) -> Result<<WriteInquiryModeCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteInquiryModeCommand<S>

where S: Storage,

type Ok = WriteInquiryModeCommand<S, OkState>

fn check_ok(self) -> Result<<WriteInquiryModeCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteInquiryModeCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = WriteInquiryModeCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<WriteInquiryModeCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteInquiryModeCommandWriter<S, OkState>

where S: MutStorage,

type Ok = WriteInquiryModeCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<WriteInquiryModeCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteInquiryModeCommandWriter<S>

where S: MutStorage,

type Ok = WriteInquiryModeCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<WriteInquiryModeCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteInquiryScanActivityCommand<S, CompleteState>

where S: Storage,

type Ok = WriteInquiryScanActivityCommand<S, OkState>

fn check_ok( self, ) -> Result<<WriteInquiryScanActivityCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteInquiryScanActivityCommand<S, OkState>

where S: Storage,

type Ok = WriteInquiryScanActivityCommand<S, OkState>

fn check_ok( self, ) -> Result<<WriteInquiryScanActivityCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteInquiryScanActivityCommand<S>

where S: Storage,

type Ok = WriteInquiryScanActivityCommand<S, OkState>

fn check_ok( self, ) -> Result<<WriteInquiryScanActivityCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteInquiryScanActivityCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = WriteInquiryScanActivityCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<WriteInquiryScanActivityCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteInquiryScanActivityCommandWriter<S, OkState>

where S: MutStorage,

type Ok = WriteInquiryScanActivityCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<WriteInquiryScanActivityCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteInquiryScanActivityCommandWriter<S>

where S: MutStorage,

type Ok = WriteInquiryScanActivityCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<WriteInquiryScanActivityCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteInquiryScanTypeCommand<S, CompleteState>

where S: Storage,

type Ok = WriteInquiryScanTypeCommand<S, OkState>

fn check_ok( self, ) -> Result<<WriteInquiryScanTypeCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteInquiryScanTypeCommand<S, OkState>

where S: Storage,

type Ok = WriteInquiryScanTypeCommand<S, OkState>

fn check_ok( self, ) -> Result<<WriteInquiryScanTypeCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteInquiryScanTypeCommand<S>

where S: Storage,

type Ok = WriteInquiryScanTypeCommand<S, OkState>

fn check_ok( self, ) -> Result<<WriteInquiryScanTypeCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteInquiryScanTypeCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = WriteInquiryScanTypeCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<WriteInquiryScanTypeCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteInquiryScanTypeCommandWriter<S, OkState>

where S: MutStorage,

type Ok = WriteInquiryScanTypeCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<WriteInquiryScanTypeCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteInquiryScanTypeCommandWriter<S>

where S: MutStorage,

type Ok = WriteInquiryScanTypeCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<WriteInquiryScanTypeCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteLEHostSupportCommand<S, CompleteState>

where S: Storage,

type Ok = WriteLEHostSupportCommand<S, OkState>

fn check_ok( self, ) -> Result<<WriteLEHostSupportCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteLEHostSupportCommand<S, OkState>

where S: Storage,

type Ok = WriteLEHostSupportCommand<S, OkState>

fn check_ok( self, ) -> Result<<WriteLEHostSupportCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteLEHostSupportCommand<S>

where S: Storage,

type Ok = WriteLEHostSupportCommand<S, OkState>

fn check_ok( self, ) -> Result<<WriteLEHostSupportCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteLEHostSupportCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = WriteLEHostSupportCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<WriteLEHostSupportCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteLEHostSupportCommandWriter<S, OkState>

where S: MutStorage,

type Ok = WriteLEHostSupportCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<WriteLEHostSupportCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteLEHostSupportCommandWriter<S>

where S: MutStorage,

type Ok = WriteLEHostSupportCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<WriteLEHostSupportCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteLocalNameCommand<S, CompleteState>

where S: Storage,

type Ok = WriteLocalNameCommand<S, OkState>

fn check_ok( self, ) -> Result<<WriteLocalNameCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteLocalNameCommand<S, OkState>

where S: Storage,

type Ok = WriteLocalNameCommand<S, OkState>

fn check_ok( self, ) -> Result<<WriteLocalNameCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteLocalNameCommand<S>

where S: Storage,

type Ok = WriteLocalNameCommand<S, OkState>

fn check_ok(self) -> Result<<WriteLocalNameCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteLocalNameCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = WriteLocalNameCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<WriteLocalNameCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteLocalNameCommandWriter<S, OkState>

where S: MutStorage,

type Ok = WriteLocalNameCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<WriteLocalNameCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteLocalNameCommandWriter<S>

where S: MutStorage,

type Ok = WriteLocalNameCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<WriteLocalNameCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for WritePageScanActivityCommand<S, CompleteState>

where S: Storage,

type Ok = WritePageScanActivityCommand<S, OkState>

fn check_ok( self, ) -> Result<<WritePageScanActivityCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WritePageScanActivityCommand<S, OkState>

where S: Storage,

type Ok = WritePageScanActivityCommand<S, OkState>

fn check_ok( self, ) -> Result<<WritePageScanActivityCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WritePageScanActivityCommand<S>

where S: Storage,

type Ok = WritePageScanActivityCommand<S, OkState>

fn check_ok( self, ) -> Result<<WritePageScanActivityCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for WritePageScanActivityCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = WritePageScanActivityCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<WritePageScanActivityCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WritePageScanActivityCommandWriter<S, OkState>

where S: MutStorage,

type Ok = WritePageScanActivityCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<WritePageScanActivityCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WritePageScanActivityCommandWriter<S>

where S: MutStorage,

type Ok = WritePageScanActivityCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<WritePageScanActivityCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for WritePageScanTypeCommand<S, CompleteState>

where S: Storage,

type Ok = WritePageScanTypeCommand<S, OkState>

fn check_ok( self, ) -> Result<<WritePageScanTypeCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WritePageScanTypeCommand<S, OkState>

where S: Storage,

type Ok = WritePageScanTypeCommand<S, OkState>

fn check_ok( self, ) -> Result<<WritePageScanTypeCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WritePageScanTypeCommand<S>

where S: Storage,

type Ok = WritePageScanTypeCommand<S, OkState>

fn check_ok(self) -> Result<<WritePageScanTypeCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for WritePageScanTypeCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = WritePageScanTypeCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<WritePageScanTypeCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WritePageScanTypeCommandWriter<S, OkState>

where S: MutStorage,

type Ok = WritePageScanTypeCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<WritePageScanTypeCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WritePageScanTypeCommandWriter<S>

where S: MutStorage,

type Ok = WritePageScanTypeCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<WritePageScanTypeCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for WritePageTimeoutCommand<S, CompleteState>

where S: Storage,

type Ok = WritePageTimeoutCommand<S, OkState>

fn check_ok( self, ) -> Result<<WritePageTimeoutCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WritePageTimeoutCommand<S, OkState>

where S: Storage,

type Ok = WritePageTimeoutCommand<S, OkState>

fn check_ok( self, ) -> Result<<WritePageTimeoutCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WritePageTimeoutCommand<S>

where S: Storage,

type Ok = WritePageTimeoutCommand<S, OkState>

fn check_ok(self) -> Result<<WritePageTimeoutCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for WritePageTimeoutCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = WritePageTimeoutCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<WritePageTimeoutCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WritePageTimeoutCommandWriter<S, OkState>

where S: MutStorage,

type Ok = WritePageTimeoutCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<WritePageTimeoutCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WritePageTimeoutCommandWriter<S>

where S: MutStorage,

type Ok = WritePageTimeoutCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<WritePageTimeoutCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for WritePinTypeCommand<S, CompleteState>

where S: Storage,

type Ok = WritePinTypeCommand<S, OkState>

fn check_ok( self, ) -> Result<<WritePinTypeCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WritePinTypeCommand<S, OkState>

where S: Storage,

type Ok = WritePinTypeCommand<S, OkState>

fn check_ok( self, ) -> Result<<WritePinTypeCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WritePinTypeCommand<S>

where S: Storage,

type Ok = WritePinTypeCommand<S, OkState>

fn check_ok(self) -> Result<<WritePinTypeCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for WritePinTypeCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = WritePinTypeCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<WritePinTypeCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WritePinTypeCommandWriter<S, OkState>

where S: MutStorage,

type Ok = WritePinTypeCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<WritePinTypeCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WritePinTypeCommandWriter<S>

where S: MutStorage,

type Ok = WritePinTypeCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<WritePinTypeCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteScanEnableCommand<S, CompleteState>

where S: Storage,

type Ok = WriteScanEnableCommand<S, OkState>

fn check_ok( self, ) -> Result<<WriteScanEnableCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteScanEnableCommand<S, OkState>

where S: Storage,

type Ok = WriteScanEnableCommand<S, OkState>

fn check_ok( self, ) -> Result<<WriteScanEnableCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteScanEnableCommand<S>

where S: Storage,

type Ok = WriteScanEnableCommand<S, OkState>

fn check_ok(self) -> Result<<WriteScanEnableCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteScanEnableCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = WriteScanEnableCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<WriteScanEnableCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteScanEnableCommandWriter<S, OkState>

where S: MutStorage,

type Ok = WriteScanEnableCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<WriteScanEnableCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteScanEnableCommandWriter<S>

where S: MutStorage,

type Ok = WriteScanEnableCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<WriteScanEnableCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteScanEnableCommand_EmbossReservedAnonymousField12<S, CompleteState>

where S: Storage,

type Ok = WriteScanEnableCommand_EmbossReservedAnonymousField12<S, OkState>

fn check_ok( self, ) -> Result<<WriteScanEnableCommand_EmbossReservedAnonymousField12<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteScanEnableCommand_EmbossReservedAnonymousField12<S, OkState>

where S: Storage,

type Ok = WriteScanEnableCommand_EmbossReservedAnonymousField12<S, OkState>

fn check_ok( self, ) -> Result<<WriteScanEnableCommand_EmbossReservedAnonymousField12<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteScanEnableCommand_EmbossReservedAnonymousField12<S>

where S: Storage,

type Ok = WriteScanEnableCommand_EmbossReservedAnonymousField12<S, OkState>

fn check_ok( self, ) -> Result<<WriteScanEnableCommand_EmbossReservedAnonymousField12<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteScanEnableCommand_EmbossReservedAnonymousField12Writer<S, CompleteState>

where S: MutStorage,

type Ok = WriteScanEnableCommand_EmbossReservedAnonymousField12Writer<S, OkState>

fn check_ok( self, ) -> Result<<WriteScanEnableCommand_EmbossReservedAnonymousField12Writer<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteScanEnableCommand_EmbossReservedAnonymousField12Writer<S, OkState>

where S: MutStorage,

type Ok = WriteScanEnableCommand_EmbossReservedAnonymousField12Writer<S, OkState>

fn check_ok( self, ) -> Result<<WriteScanEnableCommand_EmbossReservedAnonymousField12Writer<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteScanEnableCommand_EmbossReservedAnonymousField12Writer<S>

where S: MutStorage,

type Ok = WriteScanEnableCommand_EmbossReservedAnonymousField12Writer<S, OkState>

fn check_ok( self, ) -> Result<<WriteScanEnableCommand_EmbossReservedAnonymousField12Writer<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteSecureConnectionsHostSupportCommand<S, CompleteState>

where S: Storage,

type Ok = WriteSecureConnectionsHostSupportCommand<S, OkState>

fn check_ok( self, ) -> Result<<WriteSecureConnectionsHostSupportCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteSecureConnectionsHostSupportCommand<S, OkState>

where S: Storage,

type Ok = WriteSecureConnectionsHostSupportCommand<S, OkState>

fn check_ok( self, ) -> Result<<WriteSecureConnectionsHostSupportCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteSecureConnectionsHostSupportCommand<S>

where S: Storage,

type Ok = WriteSecureConnectionsHostSupportCommand<S, OkState>

fn check_ok( self, ) -> Result<<WriteSecureConnectionsHostSupportCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteSecureConnectionsHostSupportCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = WriteSecureConnectionsHostSupportCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<WriteSecureConnectionsHostSupportCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteSecureConnectionsHostSupportCommandWriter<S, OkState>

where S: MutStorage,

type Ok = WriteSecureConnectionsHostSupportCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<WriteSecureConnectionsHostSupportCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteSecureConnectionsHostSupportCommandWriter<S>

where S: MutStorage,

type Ok = WriteSecureConnectionsHostSupportCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<WriteSecureConnectionsHostSupportCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteSimplePairingDebugModeCommand<S, CompleteState>

where S: Storage,

type Ok = WriteSimplePairingDebugModeCommand<S, OkState>

fn check_ok( self, ) -> Result<<WriteSimplePairingDebugModeCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteSimplePairingDebugModeCommand<S, OkState>

where S: Storage,

type Ok = WriteSimplePairingDebugModeCommand<S, OkState>

fn check_ok( self, ) -> Result<<WriteSimplePairingDebugModeCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteSimplePairingDebugModeCommand<S>

where S: Storage,

type Ok = WriteSimplePairingDebugModeCommand<S, OkState>

fn check_ok( self, ) -> Result<<WriteSimplePairingDebugModeCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteSimplePairingDebugModeCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = WriteSimplePairingDebugModeCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<WriteSimplePairingDebugModeCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteSimplePairingDebugModeCommandWriter<S, OkState>

where S: MutStorage,

type Ok = WriteSimplePairingDebugModeCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<WriteSimplePairingDebugModeCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteSimplePairingDebugModeCommandWriter<S>

where S: MutStorage,

type Ok = WriteSimplePairingDebugModeCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<WriteSimplePairingDebugModeCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteSimplePairingModeCommand<S, CompleteState>

where S: Storage,

type Ok = WriteSimplePairingModeCommand<S, OkState>

fn check_ok( self, ) -> Result<<WriteSimplePairingModeCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteSimplePairingModeCommand<S, OkState>

where S: Storage,

type Ok = WriteSimplePairingModeCommand<S, OkState>

fn check_ok( self, ) -> Result<<WriteSimplePairingModeCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteSimplePairingModeCommand<S>

where S: Storage,

type Ok = WriteSimplePairingModeCommand<S, OkState>

fn check_ok( self, ) -> Result<<WriteSimplePairingModeCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteSimplePairingModeCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = WriteSimplePairingModeCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<WriteSimplePairingModeCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteSimplePairingModeCommandWriter<S, OkState>

where S: MutStorage,

type Ok = WriteSimplePairingModeCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<WriteSimplePairingModeCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteSimplePairingModeCommandWriter<S>

where S: MutStorage,

type Ok = WriteSimplePairingModeCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<WriteSimplePairingModeCommandWriter<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteSynchronousFlowControlEnableCommand<S, CompleteState>

where S: Storage,

type Ok = WriteSynchronousFlowControlEnableCommand<S, OkState>

fn check_ok( self, ) -> Result<<WriteSynchronousFlowControlEnableCommand<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteSynchronousFlowControlEnableCommand<S, OkState>

where S: Storage,

type Ok = WriteSynchronousFlowControlEnableCommand<S, OkState>

fn check_ok( self, ) -> Result<<WriteSynchronousFlowControlEnableCommand<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteSynchronousFlowControlEnableCommand<S>

where S: Storage,

type Ok = WriteSynchronousFlowControlEnableCommand<S, OkState>

fn check_ok( self, ) -> Result<<WriteSynchronousFlowControlEnableCommand<S> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteSynchronousFlowControlEnableCommandWriter<S, CompleteState>

where S: MutStorage,

type Ok = WriteSynchronousFlowControlEnableCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<WriteSynchronousFlowControlEnableCommandWriter<S, CompleteState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteSynchronousFlowControlEnableCommandWriter<S, OkState>

where S: MutStorage,

type Ok = WriteSynchronousFlowControlEnableCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<WriteSynchronousFlowControlEnableCommandWriter<S, OkState> as CheckOk>::Ok, Error>

impl<S> CheckOk for WriteSynchronousFlowControlEnableCommandWriter<S>

where S: MutStorage,

type Ok = WriteSynchronousFlowControlEnableCommandWriter<S, OkState>

fn check_ok( self, ) -> Result<<WriteSynchronousFlowControlEnableCommandWriter<S> as CheckOk>::Ok, Error>

Implementors