Trait CheckComplete 

pub trait CheckComplete {
    type Completed;

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

Trait for verifying dynamic layout completeness at runtime, upgrading the typestate to CompleteState.

Required Associated Types

type Completed

Required Methods

fn check_complete(self) -> Result<Self::Completed, 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> CheckComplete for AcceptConnectionRequestCommand<S>

where S: Storage,

type Completed = AcceptConnectionRequestCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<AcceptConnectionRequestCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for AcceptConnectionRequestCommandWriter<S>

where S: MutStorage,

type Completed = AcceptConnectionRequestCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<AcceptConnectionRequestCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for AclDataFrame<S>

where S: Storage,

type Completed = AclDataFrame<S, CompleteState>

fn check_complete( self, ) -> Result<<AclDataFrame<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for AclDataFrameHeader<S>

where S: Storage,

type Completed = AclDataFrameHeader<S, CompleteState>

fn check_complete( self, ) -> Result<<AclDataFrameHeader<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for AclDataFrameHeaderWriter<S>

where S: MutStorage,

type Completed = AclDataFrameHeaderWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<AclDataFrameHeaderWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for AclDataFrameHeader_EmbossReservedAnonymousField4<S>

where S: Storage,

type Completed = AclDataFrameHeader_EmbossReservedAnonymousField4<S, CompleteState>

fn check_complete( self, ) -> Result<<AclDataFrameHeader_EmbossReservedAnonymousField4<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for AclDataFrameHeader_EmbossReservedAnonymousField4Writer<S>

where S: MutStorage,

type Completed = AclDataFrameHeader_EmbossReservedAnonymousField4Writer<S, CompleteState>

fn check_complete( self, ) -> Result<<AclDataFrameHeader_EmbossReservedAnonymousField4Writer<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for AclDataFrameWriter<S>

where S: MutStorage,

type Completed = AclDataFrameWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<AclDataFrameWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for AttErrorRsp<S>

where S: Storage,

type Completed = AttErrorRsp<S, CompleteState>

fn check_complete( self, ) -> Result<<AttErrorRsp<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for AttErrorRspWriter<S>

where S: MutStorage,

type Completed = AttErrorRspWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<AttErrorRspWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for AttExchangeMtuReq<S>

where S: Storage,

type Completed = AttExchangeMtuReq<S, CompleteState>

fn check_complete( self, ) -> Result<<AttExchangeMtuReq<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for AttExchangeMtuReqWriter<S>

where S: MutStorage,

type Completed = AttExchangeMtuReqWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<AttExchangeMtuReqWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for AttExchangeMtuRsp<S>

where S: Storage,

type Completed = AttExchangeMtuRsp<S, CompleteState>

fn check_complete( self, ) -> Result<<AttExchangeMtuRsp<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for AttExchangeMtuRspWriter<S>

where S: MutStorage,

type Completed = AttExchangeMtuRspWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<AttExchangeMtuRspWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for AttExecuteWriteReq<S>

where S: Storage,

type Completed = AttExecuteWriteReq<S, CompleteState>

fn check_complete( self, ) -> Result<<AttExecuteWriteReq<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for AttExecuteWriteReqWriter<S>

where S: MutStorage,

type Completed = AttExecuteWriteReqWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<AttExecuteWriteReqWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for AttFindByTypeValueReqHeader<S>

where S: Storage,

type Completed = AttFindByTypeValueReqHeader<S, CompleteState>

fn check_complete( self, ) -> Result<<AttFindByTypeValueReqHeader<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for AttFindByTypeValueReqHeaderWriter<S>

where S: MutStorage,

type Completed = AttFindByTypeValueReqHeaderWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<AttFindByTypeValueReqHeaderWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for AttFindInformationReq<S>

where S: Storage,

type Completed = AttFindInformationReq<S, CompleteState>

fn check_complete( self, ) -> Result<<AttFindInformationReq<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for AttFindInformationReqWriter<S>

where S: MutStorage,

type Completed = AttFindInformationReqWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<AttFindInformationReqWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for AttFindInformationRspHeader<S>

where S: Storage,

type Completed = AttFindInformationRspHeader<S, CompleteState>

fn check_complete( self, ) -> Result<<AttFindInformationRspHeader<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for AttFindInformationRspHeaderWriter<S>

where S: MutStorage,

type Completed = AttFindInformationRspHeaderWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<AttFindInformationRspHeaderWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for AttHandleValueIndHeader<S>

where S: Storage,

type Completed = AttHandleValueIndHeader<S, CompleteState>

fn check_complete( self, ) -> Result<<AttHandleValueIndHeader<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for AttHandleValueIndHeaderWriter<S>

where S: MutStorage,

type Completed = AttHandleValueIndHeaderWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<AttHandleValueIndHeaderWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for AttHandleValueNtf<S>

where S: Storage,

type Completed = AttHandleValueNtf<S, CompleteState>

fn check_complete( self, ) -> Result<<AttHandleValueNtf<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for AttHandleValueNtfHeader<S>

where S: Storage,

type Completed = AttHandleValueNtfHeader<S, CompleteState>

fn check_complete( self, ) -> Result<<AttHandleValueNtfHeader<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for AttHandleValueNtfHeaderWriter<S>

where S: MutStorage,

type Completed = AttHandleValueNtfHeaderWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<AttHandleValueNtfHeaderWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for AttHandleValueNtfWriter<S>

where S: MutStorage,

type Completed = AttHandleValueNtfWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<AttHandleValueNtfWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for AttHandlesInformation<S>

where S: Storage,

type Completed = AttHandlesInformation<S, CompleteState>

fn check_complete( self, ) -> Result<<AttHandlesInformation<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for AttHandlesInformationWriter<S>

where S: MutStorage,

type Completed = AttHandlesInformationWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<AttHandlesInformationWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for AttHeader<S>

where S: Storage,

type Completed = AttHeader<S, CompleteState>

fn check_complete( self, ) -> Result<<AttHeader<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for AttHeaderWriter<S>

where S: MutStorage,

type Completed = AttHeaderWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<AttHeaderWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for AttInformationData16<S>

where S: Storage,

type Completed = AttInformationData16<S, CompleteState>

fn check_complete( self, ) -> Result<<AttInformationData16<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for AttInformationData16Writer<S>

where S: MutStorage,

type Completed = AttInformationData16Writer<S, CompleteState>

fn check_complete( self, ) -> Result<<AttInformationData16Writer<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for AttInformationData128<S>

where S: Storage,

type Completed = AttInformationData128<S, CompleteState>

fn check_complete( self, ) -> Result<<AttInformationData128<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for AttInformationData128Writer<S>

where S: MutStorage,

type Completed = AttInformationData128Writer<S, CompleteState>

fn check_complete( self, ) -> Result<<AttInformationData128Writer<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for AttPrepareWriteHeader<S>

where S: Storage,

type Completed = AttPrepareWriteHeader<S, CompleteState>

fn check_complete( self, ) -> Result<<AttPrepareWriteHeader<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for AttPrepareWriteHeaderWriter<S>

where S: MutStorage,

type Completed = AttPrepareWriteHeaderWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<AttPrepareWriteHeaderWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for AttReadBlobReq<S>

where S: Storage,

type Completed = AttReadBlobReq<S, CompleteState>

fn check_complete( self, ) -> Result<<AttReadBlobReq<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for AttReadBlobReqWriter<S>

where S: MutStorage,

type Completed = AttReadBlobReqWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<AttReadBlobReqWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for AttReadByGroupTypeReqHeader<S>

where S: Storage,

type Completed = AttReadByGroupTypeReqHeader<S, CompleteState>

fn check_complete( self, ) -> Result<<AttReadByGroupTypeReqHeader<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for AttReadByGroupTypeReqHeaderWriter<S>

where S: MutStorage,

type Completed = AttReadByGroupTypeReqHeaderWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<AttReadByGroupTypeReqHeaderWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for AttReadByGroupTypeRspEntryHeader<S>

where S: Storage,

type Completed = AttReadByGroupTypeRspEntryHeader<S, CompleteState>

fn check_complete( self, ) -> Result<<AttReadByGroupTypeRspEntryHeader<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for AttReadByGroupTypeRspEntryHeaderWriter<S>

where S: MutStorage,

type Completed = AttReadByGroupTypeRspEntryHeaderWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<AttReadByGroupTypeRspEntryHeaderWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for AttReadByTypeReqHeader<S>

where S: Storage,

type Completed = AttReadByTypeReqHeader<S, CompleteState>

fn check_complete( self, ) -> Result<<AttReadByTypeReqHeader<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for AttReadByTypeReqHeaderWriter<S>

where S: MutStorage,

type Completed = AttReadByTypeReqHeaderWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<AttReadByTypeReqHeaderWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for AttReadReq<S>

where S: Storage,

type Completed = AttReadReq<S, CompleteState>

fn check_complete( self, ) -> Result<<AttReadReq<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for AttReadReqWriter<S>

where S: MutStorage,

type Completed = AttReadReqWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<AttReadReqWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for AttWriteCmd<S>

where S: Storage,

type Completed = AttWriteCmd<S, CompleteState>

fn check_complete( self, ) -> Result<<AttWriteCmd<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for AttWriteCmdWriter<S>

where S: MutStorage,

type Completed = AttWriteCmdWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<AttWriteCmdWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for AuthenticationRequestedCommand<S>

where S: Storage,

type Completed = AuthenticationRequestedCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<AuthenticationRequestedCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for AuthenticationRequestedCommandWriter<S>

where S: MutStorage,

type Completed = AuthenticationRequestedCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<AuthenticationRequestedCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for BFrame<S>

where S: Storage,

type Completed = BFrame<S, CompleteState>

fn check_complete( self, ) -> Result<<BFrame<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for BFrameHeader<S>

where S: Storage,

type Completed = BFrameHeader<S, CompleteState>

fn check_complete( self, ) -> Result<<BFrameHeader<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for BFrameHeaderWriter<S>

where S: MutStorage,

type Completed = BFrameHeaderWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<BFrameHeaderWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for BFrameWriter<S>

where S: MutStorage,

type Completed = BFrameWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<BFrameWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for BasicL2capHeader<S>

where S: Storage,

type Completed = BasicL2capHeader<S, CompleteState>

fn check_complete( self, ) -> Result<<BasicL2capHeader<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for BasicL2capHeaderWriter<S>

where S: MutStorage,

type Completed = BasicL2capHeaderWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<BasicL2capHeaderWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for BdAddr<S>

where S: Storage,

type Completed = BdAddr<S, CompleteState>

fn check_complete( self, ) -> Result<<BdAddr<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for BdAddrWriter<S>

where S: MutStorage,

type Completed = BdAddrWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<BdAddrWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for CFrame<S>

where S: Storage,

type Completed = CFrame<S, CompleteState>

fn check_complete( self, ) -> Result<<CFrame<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for CFrameWriter<S>

where S: MutStorage,

type Completed = CFrameWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<CFrameWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ChangeConnectionPacketTypeCommand<S>

where S: Storage,

type Completed = ChangeConnectionPacketTypeCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<ChangeConnectionPacketTypeCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ChangeConnectionPacketTypeCommandWriter<S>

where S: MutStorage,

type Completed = ChangeConnectionPacketTypeCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<ChangeConnectionPacketTypeCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ClassOfDevice<S>

where S: Storage,

type Completed = ClassOfDevice<S, CompleteState>

fn check_complete( self, ) -> Result<<ClassOfDevice<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ClassOfDeviceWriter<S>

where S: MutStorage,

type Completed = ClassOfDeviceWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<ClassOfDeviceWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ClockOffset<S>

where S: Storage,

type Completed = ClockOffset<S, CompleteState>

fn check_complete( self, ) -> Result<<ClockOffset<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ClockOffsetWriter<S>

where S: MutStorage,

type Completed = ClockOffsetWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<ClockOffsetWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for CodecId<S>

where S: Storage,

type Completed = CodecId<S, CompleteState>

fn check_complete( self, ) -> Result<<CodecId<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for CodecIdWriter<S>

where S: MutStorage,

type Completed = CodecIdWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<CodecIdWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for CommandCompleteEvent<S>

where S: Storage,

type Completed = CommandCompleteEvent<S, CompleteState>

fn check_complete( self, ) -> Result<<CommandCompleteEvent<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for CommandCompleteEventWriter<S>

where S: MutStorage,

type Completed = CommandCompleteEventWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<CommandCompleteEventWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for CommandHeader<S>

where S: Storage,

type Completed = CommandHeader<S, CompleteState>

fn check_complete( self, ) -> Result<<CommandHeader<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for CommandHeaderWriter<S>

where S: MutStorage,

type Completed = CommandHeaderWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<CommandHeaderWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for CommandPacket<S>

where S: Storage,

type Completed = CommandPacket<S, CompleteState>

fn check_complete( self, ) -> Result<<CommandPacket<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for CommandPacketWriter<S>

where S: MutStorage,

type Completed = CommandPacketWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<CommandPacketWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for CreateConnectionCancelCommand<S>

where S: Storage,

type Completed = CreateConnectionCancelCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<CreateConnectionCancelCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for CreateConnectionCancelCommandWriter<S>

where S: MutStorage,

type Completed = CreateConnectionCancelCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<CreateConnectionCancelCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for CreateConnectionCommand<S>

where S: Storage,

type Completed = CreateConnectionCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<CreateConnectionCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for CreateConnectionCommandWriter<S>

where S: MutStorage,

type Completed = CreateConnectionCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<CreateConnectionCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for DisconnectCommand<S>

where S: Storage,

type Completed = DisconnectCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<DisconnectCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for DisconnectCommandWriter<S>

where S: MutStorage,

type Completed = DisconnectCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<DisconnectCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for EnhancedAcceptSynchronousConnectionRequestCommand<S>

where S: Storage,

type Completed = EnhancedAcceptSynchronousConnectionRequestCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<EnhancedAcceptSynchronousConnectionRequestCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for EnhancedAcceptSynchronousConnectionRequestCommandWriter<S>

where S: MutStorage,

type Completed = EnhancedAcceptSynchronousConnectionRequestCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<EnhancedAcceptSynchronousConnectionRequestCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for EnhancedSetupSynchronousConnectionCommand<S>

where S: Storage,

type Completed = EnhancedSetupSynchronousConnectionCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<EnhancedSetupSynchronousConnectionCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for EnhancedSetupSynchronousConnectionCommandWriter<S>

where S: MutStorage,

type Completed = EnhancedSetupSynchronousConnectionCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<EnhancedSetupSynchronousConnectionCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for EventHeader<S>

where S: Storage,

type Completed = EventHeader<S, CompleteState>

fn check_complete( self, ) -> Result<<EventHeader<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for EventHeaderWriter<S>

where S: MutStorage,

type Completed = EventHeaderWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<EventHeaderWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for EventMask<S>

where S: Storage,

type Completed = EventMask<S, CompleteState>

fn check_complete( self, ) -> Result<<EventMask<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for EventMaskPage2<S>

where S: Storage,

type Completed = EventMaskPage2<S, CompleteState>

fn check_complete( self, ) -> Result<<EventMaskPage2<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for EventMaskPage2Writer<S>

where S: MutStorage,

type Completed = EventMaskPage2Writer<S, CompleteState>

fn check_complete( self, ) -> Result<<EventMaskPage2Writer<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for EventMaskWriter<S>

where S: MutStorage,

type Completed = EventMaskWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<EventMaskWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for EventPacket<S>

where S: Storage,

type Completed = EventPacket<S, CompleteState>

fn check_complete( self, ) -> Result<<EventPacket<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for EventPacketWriter<S>

where S: MutStorage,

type Completed = EventPacketWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<EventPacketWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ExitSniffModeCommand<S>

where S: Storage,

type Completed = ExitSniffModeCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<ExitSniffModeCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ExitSniffModeCommandWriter<S>

where S: MutStorage,

type Completed = ExitSniffModeCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<ExitSniffModeCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ExtendedInquiryResponse<S>

where S: Storage,

type Completed = ExtendedInquiryResponse<S, CompleteState>

fn check_complete( self, ) -> Result<<ExtendedInquiryResponse<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ExtendedInquiryResponseWriter<S>

where S: MutStorage,

type Completed = ExtendedInquiryResponseWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<ExtendedInquiryResponseWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for FirstKFrame<S>

where S: Storage,

type Completed = FirstKFrame<S, CompleteState>

fn check_complete( self, ) -> Result<<FirstKFrame<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for FirstKFrameWriter<S>

where S: MutStorage,

type Completed = FirstKFrameWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<FirstKFrameWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for GenericHciCommand<S>

where S: Storage,

type Completed = GenericHciCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<GenericHciCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for GenericHciCommandWriter<S>

where S: MutStorage,

type Completed = GenericHciCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<GenericHciCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for HostBufferSizeCommand<S>

where S: Storage,

type Completed = HostBufferSizeCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<HostBufferSizeCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for HostBufferSizeCommandWriter<S>

where S: MutStorage,

type Completed = HostBufferSizeCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<HostBufferSizeCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ImagingMinorDeviceClassBits<S>

where S: Storage,

type Completed = ImagingMinorDeviceClassBits<S, CompleteState>

fn check_complete( self, ) -> Result<<ImagingMinorDeviceClassBits<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ImagingMinorDeviceClassBitsWriter<S>

where S: MutStorage,

type Completed = ImagingMinorDeviceClassBitsWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<ImagingMinorDeviceClassBitsWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for InquiryCancelCommand<S>

where S: Storage,

type Completed = InquiryCancelCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<InquiryCancelCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for InquiryCancelCommandWriter<S>

where S: MutStorage,

type Completed = InquiryCancelCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<InquiryCancelCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for InquiryCommand<S>

where S: Storage,

type Completed = InquiryCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<InquiryCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for InquiryCommandWriter<S>

where S: MutStorage,

type Completed = InquiryCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<InquiryCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for IoCapabilityRequestNegativeReplyCommand<S>

where S: Storage,

type Completed = IoCapabilityRequestNegativeReplyCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<IoCapabilityRequestNegativeReplyCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for IoCapabilityRequestNegativeReplyCommandWriter<S>

where S: MutStorage,

type Completed = IoCapabilityRequestNegativeReplyCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<IoCapabilityRequestNegativeReplyCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for IoCapabilityRequestReplyCommand<S>

where S: Storage,

type Completed = IoCapabilityRequestReplyCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<IoCapabilityRequestReplyCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for IoCapabilityRequestReplyCommandWriter<S>

where S: MutStorage,

type Completed = IoCapabilityRequestReplyCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<IoCapabilityRequestReplyCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for IsoDataFrameHeader<S>

where S: Storage,

type Completed = IsoDataFrameHeader<S, CompleteState>

fn check_complete( self, ) -> Result<<IsoDataFrameHeader<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for IsoDataFrameHeaderWriter<S>

where S: MutStorage,

type Completed = IsoDataFrameHeaderWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<IsoDataFrameHeaderWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for IsoDataFrameHeader_EmbossReservedAnonymousField3<S>

where S: Storage,

type Completed = IsoDataFrameHeader_EmbossReservedAnonymousField3<S, CompleteState>

fn check_complete( self, ) -> Result<<IsoDataFrameHeader_EmbossReservedAnonymousField3<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for IsoDataFrameHeader_EmbossReservedAnonymousField3Writer<S>

where S: MutStorage,

type Completed = IsoDataFrameHeader_EmbossReservedAnonymousField3Writer<S, CompleteState>

fn check_complete( self, ) -> Result<<IsoDataFrameHeader_EmbossReservedAnonymousField3Writer<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for IsoDataFramePacket<S>

where S: Storage,

type Completed = IsoDataFramePacket<S, CompleteState>

fn check_complete( self, ) -> Result<<IsoDataFramePacket<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for IsoDataFramePacketWriter<S>

where S: MutStorage,

type Completed = IsoDataFramePacketWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<IsoDataFramePacketWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for IsoDataFramePacket_EmbossReservedAnonymousField2<S>

where S: Storage,

type Completed = IsoDataFramePacket_EmbossReservedAnonymousField2<S, CompleteState>

fn check_complete( self, ) -> Result<<IsoDataFramePacket_EmbossReservedAnonymousField2<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for IsoDataFramePacket_EmbossReservedAnonymousField2Writer<S>

where S: MutStorage,

type Completed = IsoDataFramePacket_EmbossReservedAnonymousField2Writer<S, CompleteState>

fn check_complete( self, ) -> Result<<IsoDataFramePacket_EmbossReservedAnonymousField2Writer<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for KFramePduHeader<S>

where S: Storage,

type Completed = KFramePduHeader<S, CompleteState>

fn check_complete( self, ) -> Result<<KFramePduHeader<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for KFramePduHeaderWriter<S>

where S: MutStorage,

type Completed = KFramePduHeaderWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<KFramePduHeaderWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for KFrameSduHeader<S>

where S: Storage,

type Completed = KFrameSduHeader<S, CompleteState>

fn check_complete( self, ) -> Result<<KFrameSduHeader<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for KFrameSduHeaderWriter<S>

where S: MutStorage,

type Completed = KFrameSduHeaderWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<KFrameSduHeaderWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for L2capCommandRejectRsp<S>

where S: Storage,

type Completed = L2capCommandRejectRsp<S, CompleteState>

fn check_complete( self, ) -> Result<<L2capCommandRejectRsp<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for L2capCommandRejectRspWriter<S>

where S: MutStorage,

type Completed = L2capCommandRejectRspWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<L2capCommandRejectRspWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for L2capConfigurationOptionHeader<S>

where S: Storage,

type Completed = L2capConfigurationOptionHeader<S, CompleteState>

fn check_complete( self, ) -> Result<<L2capConfigurationOptionHeader<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for L2capConfigurationOptionHeaderWriter<S>

where S: MutStorage,

type Completed = L2capConfigurationOptionHeaderWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<L2capConfigurationOptionHeaderWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for L2capConfigureReq<S>

where S: Storage,

type Completed = L2capConfigureReq<S, CompleteState>

fn check_complete( self, ) -> Result<<L2capConfigureReq<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for L2capConfigureReqWriter<S>

where S: MutStorage,

type Completed = L2capConfigureReqWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<L2capConfigureReqWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for L2capConfigureReq_EmbossReservedAnonymousField2<S>

where S: Storage,

type Completed = L2capConfigureReq_EmbossReservedAnonymousField2<S, CompleteState>

fn check_complete( self, ) -> Result<<L2capConfigureReq_EmbossReservedAnonymousField2<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for L2capConfigureReq_EmbossReservedAnonymousField2Writer<S>

where S: MutStorage,

type Completed = L2capConfigureReq_EmbossReservedAnonymousField2Writer<S, CompleteState>

fn check_complete( self, ) -> Result<<L2capConfigureReq_EmbossReservedAnonymousField2Writer<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for L2capConfigureRsp<S>

where S: Storage,

type Completed = L2capConfigureRsp<S, CompleteState>

fn check_complete( self, ) -> Result<<L2capConfigureRsp<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for L2capConfigureRspWriter<S>

where S: MutStorage,

type Completed = L2capConfigureRspWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<L2capConfigureRspWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for L2capConfigureRsp_EmbossReservedAnonymousField1<S>

where S: Storage,

type Completed = L2capConfigureRsp_EmbossReservedAnonymousField1<S, CompleteState>

fn check_complete( self, ) -> Result<<L2capConfigureRsp_EmbossReservedAnonymousField1<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for L2capConfigureRsp_EmbossReservedAnonymousField1Writer<S>

where S: MutStorage,

type Completed = L2capConfigureRsp_EmbossReservedAnonymousField1Writer<S, CompleteState>

fn check_complete( self, ) -> Result<<L2capConfigureRsp_EmbossReservedAnonymousField1Writer<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for L2capConnectionReq<S>

where S: Storage,

type Completed = L2capConnectionReq<S, CompleteState>

fn check_complete( self, ) -> Result<<L2capConnectionReq<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for L2capConnectionReqWriter<S>

where S: MutStorage,

type Completed = L2capConnectionReqWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<L2capConnectionReqWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for L2capConnectionRsp<S>

where S: Storage,

type Completed = L2capConnectionRsp<S, CompleteState>

fn check_complete( self, ) -> Result<<L2capConnectionRsp<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for L2capConnectionRspWriter<S>

where S: MutStorage,

type Completed = L2capConnectionRspWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<L2capConnectionRspWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for L2capDisconnectionReq<S>

where S: Storage,

type Completed = L2capDisconnectionReq<S, CompleteState>

fn check_complete( self, ) -> Result<<L2capDisconnectionReq<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for L2capDisconnectionReqWriter<S>

where S: MutStorage,

type Completed = L2capDisconnectionReqWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<L2capDisconnectionReqWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for L2capDisconnectionRsp<S>

where S: Storage,

type Completed = L2capDisconnectionRsp<S, CompleteState>

fn check_complete( self, ) -> Result<<L2capDisconnectionRsp<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for L2capDisconnectionRspWriter<S>

where S: MutStorage,

type Completed = L2capDisconnectionRspWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<L2capDisconnectionRspWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for L2capFlowControlCreditInd<S>

where S: Storage,

type Completed = L2capFlowControlCreditInd<S, CompleteState>

fn check_complete( self, ) -> Result<<L2capFlowControlCreditInd<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for L2capFlowControlCreditIndWriter<S>

where S: MutStorage,

type Completed = L2capFlowControlCreditIndWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<L2capFlowControlCreditIndWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for L2capLeCreditBasedConnectionReq<S>

where S: Storage,

type Completed = L2capLeCreditBasedConnectionReq<S, CompleteState>

fn check_complete( self, ) -> Result<<L2capLeCreditBasedConnectionReq<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for L2capLeCreditBasedConnectionReqWriter<S>

where S: MutStorage,

type Completed = L2capLeCreditBasedConnectionReqWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<L2capLeCreditBasedConnectionReqWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for L2capMtuConfigurationOption<S>

where S: Storage,

type Completed = L2capMtuConfigurationOption<S, CompleteState>

fn check_complete( self, ) -> Result<<L2capMtuConfigurationOption<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for L2capMtuConfigurationOptionWriter<S>

where S: MutStorage,

type Completed = L2capMtuConfigurationOptionWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<L2capMtuConfigurationOptionWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for L2capSignalingCommand<S>

where S: Storage,

type Completed = L2capSignalingCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<L2capSignalingCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for L2capSignalingCommandHeader<S>

where S: Storage,

type Completed = L2capSignalingCommandHeader<S, CompleteState>

fn check_complete( self, ) -> Result<<L2capSignalingCommandHeader<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for L2capSignalingCommandHeaderWriter<S>

where S: MutStorage,

type Completed = L2capSignalingCommandHeaderWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<L2capSignalingCommandHeaderWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for L2capSignalingCommandWriter<S>

where S: MutStorage,

type Completed = L2capSignalingCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<L2capSignalingCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEAcceptCISRequestCommand<S>

where S: Storage,

type Completed = LEAcceptCISRequestCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<LEAcceptCISRequestCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEAcceptCISRequestCommandWriter<S>

where S: MutStorage,

type Completed = LEAcceptCISRequestCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LEAcceptCISRequestCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEAddDeviceToFilterAcceptListCommand<S>

where S: Storage,

type Completed = LEAddDeviceToFilterAcceptListCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<LEAddDeviceToFilterAcceptListCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEAddDeviceToFilterAcceptListCommandWriter<S>

where S: MutStorage,

type Completed = LEAddDeviceToFilterAcceptListCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LEAddDeviceToFilterAcceptListCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEAddDeviceToPeriodicAdvertiserListCommand<S>

where S: Storage,

type Completed = LEAddDeviceToPeriodicAdvertiserListCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<LEAddDeviceToPeriodicAdvertiserListCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEAddDeviceToPeriodicAdvertiserListCommandWriter<S>

where S: MutStorage,

type Completed = LEAddDeviceToPeriodicAdvertiserListCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LEAddDeviceToPeriodicAdvertiserListCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEAdvertisingChannels<S>

where S: Storage,

type Completed = LEAdvertisingChannels<S, CompleteState>

fn check_complete( self, ) -> Result<<LEAdvertisingChannels<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEAdvertisingChannelsWriter<S>

where S: MutStorage,

type Completed = LEAdvertisingChannelsWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LEAdvertisingChannelsWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEAdvertisingEventProperties<S>

where S: Storage,

type Completed = LEAdvertisingEventProperties<S, CompleteState>

fn check_complete( self, ) -> Result<<LEAdvertisingEventProperties<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEAdvertisingEventPropertiesWriter<S>

where S: MutStorage,

type Completed = LEAdvertisingEventPropertiesWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LEAdvertisingEventPropertiesWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEAdvertisingEventProperties_EmbossReservedAnonymousField18<S>

where S: Storage,

type Completed = LEAdvertisingEventProperties_EmbossReservedAnonymousField18<S, CompleteState>

fn check_complete( self, ) -> Result<<LEAdvertisingEventProperties_EmbossReservedAnonymousField18<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEAdvertisingEventProperties_EmbossReservedAnonymousField18Writer<S>

where S: MutStorage,

type Completed = LEAdvertisingEventProperties_EmbossReservedAnonymousField18Writer<S, CompleteState>

fn check_complete( self, ) -> Result<<LEAdvertisingEventProperties_EmbossReservedAnonymousField18Writer<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LECISPHYOptions<S>

where S: Storage,

type Completed = LECISPHYOptions<S, CompleteState>

fn check_complete( self, ) -> Result<<LECISPHYOptions<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LECISPHYOptionsWriter<S>

where S: MutStorage,

type Completed = LECISPHYOptionsWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LECISPHYOptionsWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEClearAdvertisingSetsCommand<S>

where S: Storage,

type Completed = LEClearAdvertisingSetsCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<LEClearAdvertisingSetsCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEClearAdvertisingSetsCommandWriter<S>

where S: MutStorage,

type Completed = LEClearAdvertisingSetsCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LEClearAdvertisingSetsCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEClearFilterAcceptListCommand<S>

where S: Storage,

type Completed = LEClearFilterAcceptListCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<LEClearFilterAcceptListCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEClearFilterAcceptListCommandWriter<S>

where S: MutStorage,

type Completed = LEClearFilterAcceptListCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LEClearFilterAcceptListCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEClearPeriodicAdvertiserListCommand<S>

where S: Storage,

type Completed = LEClearPeriodicAdvertiserListCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<LEClearPeriodicAdvertiserListCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEClearPeriodicAdvertiserListCommandWriter<S>

where S: MutStorage,

type Completed = LEClearPeriodicAdvertiserListCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LEClearPeriodicAdvertiserListCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEClearResolvingListCommand<S>

where S: Storage,

type Completed = LEClearResolvingListCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<LEClearResolvingListCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEClearResolvingListCommandWriter<S>

where S: MutStorage,

type Completed = LEClearResolvingListCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LEClearResolvingListCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEConnectionUpdateCommand<S>

where S: Storage,

type Completed = LEConnectionUpdateCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<LEConnectionUpdateCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEConnectionUpdateCommandWriter<S>

where S: MutStorage,

type Completed = LEConnectionUpdateCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LEConnectionUpdateCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LECreateCISCommand<S>

where S: Storage,

type Completed = LECreateCISCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<LECreateCISCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LECreateCISCommandWriter<S>

where S: MutStorage,

type Completed = LECreateCISCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LECreateCISCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LECreateCISCommand_ConnectionInfo<S>

where S: Storage,

type Completed = LECreateCISCommand_ConnectionInfo<S, CompleteState>

fn check_complete( self, ) -> Result<<LECreateCISCommand_ConnectionInfo<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LECreateCISCommand_ConnectionInfoWriter<S>

where S: MutStorage,

type Completed = LECreateCISCommand_ConnectionInfoWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LECreateCISCommand_ConnectionInfoWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LECreateConnectionCancelCommand<S>

where S: Storage,

type Completed = LECreateConnectionCancelCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<LECreateConnectionCancelCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LECreateConnectionCancelCommandWriter<S>

where S: MutStorage,

type Completed = LECreateConnectionCancelCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LECreateConnectionCancelCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LECreateConnectionCommand<S>

where S: Storage,

type Completed = LECreateConnectionCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<LECreateConnectionCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LECreateConnectionCommandWriter<S>

where S: MutStorage,

type Completed = LECreateConnectionCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LECreateConnectionCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEEnableEncryptionCommand<S>

where S: Storage,

type Completed = LEEnableEncryptionCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<LEEnableEncryptionCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEEnableEncryptionCommandWriter<S>

where S: MutStorage,

type Completed = LEEnableEncryptionCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LEEnableEncryptionCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEEventMask<S>

where S: Storage,

type Completed = LEEventMask<S, CompleteState>

fn check_complete( self, ) -> Result<<LEEventMask<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEEventMaskWriter<S>

where S: MutStorage,

type Completed = LEEventMaskWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LEEventMaskWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEExtendedCreateConnectionCommandV1<S>

where S: Storage,

type Completed = LEExtendedCreateConnectionCommandV1<S, CompleteState>

fn check_complete( self, ) -> Result<<LEExtendedCreateConnectionCommandV1<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEExtendedCreateConnectionCommandV1Writer<S>

where S: MutStorage,

type Completed = LEExtendedCreateConnectionCommandV1Writer<S, CompleteState>

fn check_complete( self, ) -> Result<<LEExtendedCreateConnectionCommandV1Writer<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEExtendedCreateConnectionCommandV1_EmbossReservedAnonymousField6<S>

where S: Storage,

type Completed = LEExtendedCreateConnectionCommandV1_EmbossReservedAnonymousField6<S, CompleteState>

fn check_complete( self, ) -> Result<<LEExtendedCreateConnectionCommandV1_EmbossReservedAnonymousField6<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEExtendedCreateConnectionCommandV1_EmbossReservedAnonymousField6Writer<S>

where S: MutStorage,

type Completed = LEExtendedCreateConnectionCommandV1_EmbossReservedAnonymousField6Writer<S, CompleteState>

fn check_complete( self, ) -> Result<<LEExtendedCreateConnectionCommandV1_EmbossReservedAnonymousField6Writer<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEExtendedCreateConnectionData<S>

where S: Storage,

type Completed = LEExtendedCreateConnectionData<S, CompleteState>

fn check_complete( self, ) -> Result<<LEExtendedCreateConnectionData<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEExtendedCreateConnectionDataWriter<S>

where S: MutStorage,

type Completed = LEExtendedCreateConnectionDataWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LEExtendedCreateConnectionDataWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEInitiatingPHYBits<S>

where S: Storage,

type Completed = LEInitiatingPHYBits<S, CompleteState>

fn check_complete( self, ) -> Result<<LEInitiatingPHYBits<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEInitiatingPHYBitsWriter<S>

where S: MutStorage,

type Completed = LEInitiatingPHYBitsWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LEInitiatingPHYBitsWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LELongTermKeyRequestNegativeReplyCommand<S>

where S: Storage,

type Completed = LELongTermKeyRequestNegativeReplyCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<LELongTermKeyRequestNegativeReplyCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LELongTermKeyRequestNegativeReplyCommandWriter<S>

where S: MutStorage,

type Completed = LELongTermKeyRequestNegativeReplyCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LELongTermKeyRequestNegativeReplyCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LELongTermKeyRequestReplyCommand<S>

where S: Storage,

type Completed = LELongTermKeyRequestReplyCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<LELongTermKeyRequestReplyCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LELongTermKeyRequestReplyCommandWriter<S>

where S: MutStorage,

type Completed = LELongTermKeyRequestReplyCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LELongTermKeyRequestReplyCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEPeriodicAdvertisingCreateSyncCancelCommand<S>

where S: Storage,

type Completed = LEPeriodicAdvertisingCreateSyncCancelCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<LEPeriodicAdvertisingCreateSyncCancelCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEPeriodicAdvertisingCreateSyncCancelCommandWriter<S>

where S: MutStorage,

type Completed = LEPeriodicAdvertisingCreateSyncCancelCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LEPeriodicAdvertisingCreateSyncCancelCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEPeriodicAdvertisingCreateSyncCommand<S>

where S: Storage,

type Completed = LEPeriodicAdvertisingCreateSyncCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<LEPeriodicAdvertisingCreateSyncCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEPeriodicAdvertisingCreateSyncCommandWriter<S>

where S: MutStorage,

type Completed = LEPeriodicAdvertisingCreateSyncCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LEPeriodicAdvertisingCreateSyncCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEPeriodicAdvertisingCreateSyncCommand_EmbossReservedAnonymousField4<S>

where S: Storage,

type Completed = LEPeriodicAdvertisingCreateSyncCommand_EmbossReservedAnonymousField4<S, CompleteState>

fn check_complete( self, ) -> Result<<LEPeriodicAdvertisingCreateSyncCommand_EmbossReservedAnonymousField4<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEPeriodicAdvertisingCreateSyncCommand_EmbossReservedAnonymousField4Writer<S>

where S: MutStorage,

type Completed = LEPeriodicAdvertisingCreateSyncCommand_EmbossReservedAnonymousField4Writer<S, CompleteState>

fn check_complete( self, ) -> Result<<LEPeriodicAdvertisingCreateSyncCommand_EmbossReservedAnonymousField4Writer<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEPeriodicAdvertisingCreateSyncCommand_EmbossReservedAnonymousField5<S>

where S: Storage,

type Completed = LEPeriodicAdvertisingCreateSyncCommand_EmbossReservedAnonymousField5<S, CompleteState>

fn check_complete( self, ) -> Result<<LEPeriodicAdvertisingCreateSyncCommand_EmbossReservedAnonymousField5<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEPeriodicAdvertisingCreateSyncCommand_EmbossReservedAnonymousField5Writer<S>

where S: MutStorage,

type Completed = LEPeriodicAdvertisingCreateSyncCommand_EmbossReservedAnonymousField5Writer<S, CompleteState>

fn check_complete( self, ) -> Result<<LEPeriodicAdvertisingCreateSyncCommand_EmbossReservedAnonymousField5Writer<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEPeriodicAdvertisingCreateSyncOptions<S>

where S: Storage,

type Completed = LEPeriodicAdvertisingCreateSyncOptions<S, CompleteState>

fn check_complete( self, ) -> Result<<LEPeriodicAdvertisingCreateSyncOptions<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEPeriodicAdvertisingCreateSyncOptionsWriter<S>

where S: MutStorage,

type Completed = LEPeriodicAdvertisingCreateSyncOptionsWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LEPeriodicAdvertisingCreateSyncOptionsWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEPeriodicAdvertisingSyncCteType<S>

where S: Storage,

type Completed = LEPeriodicAdvertisingSyncCteType<S, CompleteState>

fn check_complete( self, ) -> Result<<LEPeriodicAdvertisingSyncCteType<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEPeriodicAdvertisingSyncCteTypeWriter<S>

where S: MutStorage,

type Completed = LEPeriodicAdvertisingSyncCteTypeWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LEPeriodicAdvertisingSyncCteTypeWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEPeriodicAdvertisingSyncTransferCommand<S>

where S: Storage,

type Completed = LEPeriodicAdvertisingSyncTransferCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<LEPeriodicAdvertisingSyncTransferCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEPeriodicAdvertisingSyncTransferCommandWriter<S>

where S: MutStorage,

type Completed = LEPeriodicAdvertisingSyncTransferCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LEPeriodicAdvertisingSyncTransferCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEPeriodicAdvertisingTerminateSyncCommand<S>

where S: Storage,

type Completed = LEPeriodicAdvertisingTerminateSyncCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<LEPeriodicAdvertisingTerminateSyncCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEPeriodicAdvertisingTerminateSyncCommandWriter<S>

where S: MutStorage,

type Completed = LEPeriodicAdvertisingTerminateSyncCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LEPeriodicAdvertisingTerminateSyncCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LERandCommand<S>

where S: Storage,

type Completed = LERandCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<LERandCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LERandCommandWriter<S>

where S: MutStorage,

type Completed = LERandCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LERandCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEReadAdvertisingChannelTxPowerCommand<S>

where S: Storage,

type Completed = LEReadAdvertisingChannelTxPowerCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<LEReadAdvertisingChannelTxPowerCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEReadAdvertisingChannelTxPowerCommandWriter<S>

where S: MutStorage,

type Completed = LEReadAdvertisingChannelTxPowerCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LEReadAdvertisingChannelTxPowerCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEReadBufferSizeCommandV1<S>

where S: Storage,

type Completed = LEReadBufferSizeCommandV1<S, CompleteState>

fn check_complete( self, ) -> Result<<LEReadBufferSizeCommandV1<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEReadBufferSizeCommandV1Writer<S>

where S: MutStorage,

type Completed = LEReadBufferSizeCommandV1Writer<S, CompleteState>

fn check_complete( self, ) -> Result<<LEReadBufferSizeCommandV1Writer<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEReadBufferSizeCommandV2<S>

where S: Storage,

type Completed = LEReadBufferSizeCommandV2<S, CompleteState>

fn check_complete( self, ) -> Result<<LEReadBufferSizeCommandV2<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEReadBufferSizeCommandV2Writer<S>

where S: MutStorage,

type Completed = LEReadBufferSizeCommandV2Writer<S, CompleteState>

fn check_complete( self, ) -> Result<<LEReadBufferSizeCommandV2Writer<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEReadISOTXSyncCommand<S>

where S: Storage,

type Completed = LEReadISOTXSyncCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<LEReadISOTXSyncCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEReadISOTXSyncCommandWriter<S>

where S: MutStorage,

type Completed = LEReadISOTXSyncCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LEReadISOTXSyncCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEReadLocalSupportedFeaturesCommand<S>

where S: Storage,

type Completed = LEReadLocalSupportedFeaturesCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<LEReadLocalSupportedFeaturesCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEReadLocalSupportedFeaturesCommandWriter<S>

where S: MutStorage,

type Completed = LEReadLocalSupportedFeaturesCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LEReadLocalSupportedFeaturesCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEReadMaxAdvertisingDataLengthCommand<S>

where S: Storage,

type Completed = LEReadMaxAdvertisingDataLengthCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<LEReadMaxAdvertisingDataLengthCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEReadMaxAdvertisingDataLengthCommandWriter<S>

where S: MutStorage,

type Completed = LEReadMaxAdvertisingDataLengthCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LEReadMaxAdvertisingDataLengthCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEReadNumSupportedAdvertisingSetsCommand<S>

where S: Storage,

type Completed = LEReadNumSupportedAdvertisingSetsCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<LEReadNumSupportedAdvertisingSetsCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEReadNumSupportedAdvertisingSetsCommandWriter<S>

where S: MutStorage,

type Completed = LEReadNumSupportedAdvertisingSetsCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LEReadNumSupportedAdvertisingSetsCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEReadRFPathCompensationCommand<S>

where S: Storage,

type Completed = LEReadRFPathCompensationCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<LEReadRFPathCompensationCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEReadRFPathCompensationCommandWriter<S>

where S: MutStorage,

type Completed = LEReadRFPathCompensationCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LEReadRFPathCompensationCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEReadRemoteFeaturesCommand<S>

where S: Storage,

type Completed = LEReadRemoteFeaturesCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<LEReadRemoteFeaturesCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEReadRemoteFeaturesCommandWriter<S>

where S: MutStorage,

type Completed = LEReadRemoteFeaturesCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LEReadRemoteFeaturesCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEReadSupportedStatesCommand<S>

where S: Storage,

type Completed = LEReadSupportedStatesCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<LEReadSupportedStatesCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEReadSupportedStatesCommandWriter<S>

where S: MutStorage,

type Completed = LEReadSupportedStatesCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LEReadSupportedStatesCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEReadTransmitPowerCommand<S>

where S: Storage,

type Completed = LEReadTransmitPowerCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<LEReadTransmitPowerCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEReadTransmitPowerCommandWriter<S>

where S: MutStorage,

type Completed = LEReadTransmitPowerCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LEReadTransmitPowerCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LERejectCISRequestCommand<S>

where S: Storage,

type Completed = LERejectCISRequestCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<LERejectCISRequestCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LERejectCISRequestCommandWriter<S>

where S: MutStorage,

type Completed = LERejectCISRequestCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LERejectCISRequestCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LERemoveAdvertisingSetCommand<S>

where S: Storage,

type Completed = LERemoveAdvertisingSetCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<LERemoveAdvertisingSetCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LERemoveAdvertisingSetCommandWriter<S>

where S: MutStorage,

type Completed = LERemoveAdvertisingSetCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LERemoveAdvertisingSetCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LERemoveCIGCommand<S>

where S: Storage,

type Completed = LERemoveCIGCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<LERemoveCIGCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LERemoveCIGCommandWriter<S>

where S: MutStorage,

type Completed = LERemoveCIGCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LERemoveCIGCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LERemoveDeviceFromFilterAcceptListCommand<S>

where S: Storage,

type Completed = LERemoveDeviceFromFilterAcceptListCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<LERemoveDeviceFromFilterAcceptListCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LERemoveDeviceFromFilterAcceptListCommandWriter<S>

where S: MutStorage,

type Completed = LERemoveDeviceFromFilterAcceptListCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LERemoveDeviceFromFilterAcceptListCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LERemoveDeviceFromPeriodicAdvertiserListCommand<S>

where S: Storage,

type Completed = LERemoveDeviceFromPeriodicAdvertiserListCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<LERemoveDeviceFromPeriodicAdvertiserListCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LERemoveDeviceFromPeriodicAdvertiserListCommandWriter<S>

where S: MutStorage,

type Completed = LERemoveDeviceFromPeriodicAdvertiserListCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LERemoveDeviceFromPeriodicAdvertiserListCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LERemoveISODataPathCommand<S>

where S: Storage,

type Completed = LERemoveISODataPathCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<LERemoveISODataPathCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LERemoveISODataPathCommandWriter<S>

where S: MutStorage,

type Completed = LERemoveISODataPathCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LERemoveISODataPathCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LERemoveISODataPathCommand_EmbossReservedAnonymousField1<S>

where S: Storage,

type Completed = LERemoveISODataPathCommand_EmbossReservedAnonymousField1<S, CompleteState>

fn check_complete( self, ) -> Result<<LERemoveISODataPathCommand_EmbossReservedAnonymousField1<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LERemoveISODataPathCommand_EmbossReservedAnonymousField1Writer<S>

where S: MutStorage,

type Completed = LERemoveISODataPathCommand_EmbossReservedAnonymousField1Writer<S, CompleteState>

fn check_complete( self, ) -> Result<<LERemoveISODataPathCommand_EmbossReservedAnonymousField1Writer<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LERequestPeerSCACommand<S>

where S: Storage,

type Completed = LERequestPeerSCACommand<S, CompleteState>

fn check_complete( self, ) -> Result<<LERequestPeerSCACommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LERequestPeerSCACommandWriter<S>

where S: MutStorage,

type Completed = LERequestPeerSCACommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LERequestPeerSCACommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEScanPHYBits<S>

where S: Storage,

type Completed = LEScanPHYBits<S, CompleteState>

fn check_complete( self, ) -> Result<<LEScanPHYBits<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEScanPHYBitsWriter<S>

where S: MutStorage,

type Completed = LEScanPHYBitsWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LEScanPHYBitsWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LESetAddressResolutionEnableCommand<S>

where S: Storage,

type Completed = LESetAddressResolutionEnableCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<LESetAddressResolutionEnableCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LESetAddressResolutionEnableCommandWriter<S>

where S: MutStorage,

type Completed = LESetAddressResolutionEnableCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LESetAddressResolutionEnableCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LESetAdvertisingDataCommand<S>

where S: Storage,

type Completed = LESetAdvertisingDataCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<LESetAdvertisingDataCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LESetAdvertisingDataCommandWriter<S>

where S: MutStorage,

type Completed = LESetAdvertisingDataCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LESetAdvertisingDataCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LESetAdvertisingEnableCommand<S>

where S: Storage,

type Completed = LESetAdvertisingEnableCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<LESetAdvertisingEnableCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LESetAdvertisingEnableCommandWriter<S>

where S: MutStorage,

type Completed = LESetAdvertisingEnableCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LESetAdvertisingEnableCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LESetAdvertisingParametersCommand<S>

where S: Storage,

type Completed = LESetAdvertisingParametersCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<LESetAdvertisingParametersCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LESetAdvertisingParametersCommandWriter<S>

where S: MutStorage,

type Completed = LESetAdvertisingParametersCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LESetAdvertisingParametersCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LESetAdvertisingParametersCommand_EmbossReservedAnonymousField9<S>

where S: Storage,

type Completed = LESetAdvertisingParametersCommand_EmbossReservedAnonymousField9<S, CompleteState>

fn check_complete( self, ) -> Result<<LESetAdvertisingParametersCommand_EmbossReservedAnonymousField9<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LESetAdvertisingParametersCommand_EmbossReservedAnonymousField9Writer<S>

where S: MutStorage,

type Completed = LESetAdvertisingParametersCommand_EmbossReservedAnonymousField9Writer<S, CompleteState>

fn check_complete( self, ) -> Result<<LESetAdvertisingParametersCommand_EmbossReservedAnonymousField9Writer<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LESetAdvertisingSetRandomAddressCommand<S>

where S: Storage,

type Completed = LESetAdvertisingSetRandomAddressCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<LESetAdvertisingSetRandomAddressCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LESetAdvertisingSetRandomAddressCommandWriter<S>

where S: MutStorage,

type Completed = LESetAdvertisingSetRandomAddressCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LESetAdvertisingSetRandomAddressCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LESetCIGParametersCISOptions<S>

where S: Storage,

type Completed = LESetCIGParametersCISOptions<S, CompleteState>

fn check_complete( self, ) -> Result<<LESetCIGParametersCISOptions<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LESetCIGParametersCISOptionsWriter<S>

where S: MutStorage,

type Completed = LESetCIGParametersCISOptionsWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LESetCIGParametersCISOptionsWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LESetCIGParametersCISOptions_EmbossReservedAnonymousField16<S>

where S: Storage,

type Completed = LESetCIGParametersCISOptions_EmbossReservedAnonymousField16<S, CompleteState>

fn check_complete( self, ) -> Result<<LESetCIGParametersCISOptions_EmbossReservedAnonymousField16<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LESetCIGParametersCISOptions_EmbossReservedAnonymousField16Writer<S>

where S: MutStorage,

type Completed = LESetCIGParametersCISOptions_EmbossReservedAnonymousField16Writer<S, CompleteState>

fn check_complete( self, ) -> Result<<LESetCIGParametersCISOptions_EmbossReservedAnonymousField16Writer<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LESetCIGParametersCISOptions_EmbossReservedAnonymousField17<S>

where S: Storage,

type Completed = LESetCIGParametersCISOptions_EmbossReservedAnonymousField17<S, CompleteState>

fn check_complete( self, ) -> Result<<LESetCIGParametersCISOptions_EmbossReservedAnonymousField17<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LESetCIGParametersCISOptions_EmbossReservedAnonymousField17Writer<S>

where S: MutStorage,

type Completed = LESetCIGParametersCISOptions_EmbossReservedAnonymousField17Writer<S, CompleteState>

fn check_complete( self, ) -> Result<<LESetCIGParametersCISOptions_EmbossReservedAnonymousField17Writer<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LESetCIGParametersCommand<S>

where S: Storage,

type Completed = LESetCIGParametersCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<LESetCIGParametersCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LESetCIGParametersCommandWriter<S>

where S: MutStorage,

type Completed = LESetCIGParametersCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LESetCIGParametersCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LESetEventMaskCommand<S>

where S: Storage,

type Completed = LESetEventMaskCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<LESetEventMaskCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LESetEventMaskCommandWriter<S>

where S: MutStorage,

type Completed = LESetEventMaskCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LESetEventMaskCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LESetEventMaskCommand_EmbossReservedAnonymousField10<S>

where S: Storage,

type Completed = LESetEventMaskCommand_EmbossReservedAnonymousField10<S, CompleteState>

fn check_complete( self, ) -> Result<<LESetEventMaskCommand_EmbossReservedAnonymousField10<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LESetEventMaskCommand_EmbossReservedAnonymousField10Writer<S>

where S: MutStorage,

type Completed = LESetEventMaskCommand_EmbossReservedAnonymousField10Writer<S, CompleteState>

fn check_complete( self, ) -> Result<<LESetEventMaskCommand_EmbossReservedAnonymousField10Writer<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LESetExtendedAdvertisingDataCommand<S>

where S: Storage,

type Completed = LESetExtendedAdvertisingDataCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<LESetExtendedAdvertisingDataCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LESetExtendedAdvertisingDataCommandWriter<S>

where S: MutStorage,

type Completed = LESetExtendedAdvertisingDataCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LESetExtendedAdvertisingDataCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LESetExtendedAdvertisingEnableCommand<S>

where S: Storage,

type Completed = LESetExtendedAdvertisingEnableCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<LESetExtendedAdvertisingEnableCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LESetExtendedAdvertisingEnableCommandWriter<S>

where S: MutStorage,

type Completed = LESetExtendedAdvertisingEnableCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LESetExtendedAdvertisingEnableCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LESetExtendedAdvertisingEnableData<S>

where S: Storage,

type Completed = LESetExtendedAdvertisingEnableData<S, CompleteState>

fn check_complete( self, ) -> Result<<LESetExtendedAdvertisingEnableData<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LESetExtendedAdvertisingEnableDataWriter<S>

where S: MutStorage,

type Completed = LESetExtendedAdvertisingEnableDataWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LESetExtendedAdvertisingEnableDataWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LESetExtendedAdvertisingParametersV1Command<S>

where S: Storage,

type Completed = LESetExtendedAdvertisingParametersV1Command<S, CompleteState>

fn check_complete( self, ) -> Result<<LESetExtendedAdvertisingParametersV1Command<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LESetExtendedAdvertisingParametersV1CommandWriter<S>

where S: MutStorage,

type Completed = LESetExtendedAdvertisingParametersV1CommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LESetExtendedAdvertisingParametersV1CommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LESetExtendedAdvertisingParametersV1Command_EmbossReservedAnonymousField8<S>

where S: Storage,

type Completed = LESetExtendedAdvertisingParametersV1Command_EmbossReservedAnonymousField8<S, CompleteState>

fn check_complete( self, ) -> Result<<LESetExtendedAdvertisingParametersV1Command_EmbossReservedAnonymousField8<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LESetExtendedAdvertisingParametersV1Command_EmbossReservedAnonymousField8Writer<S>

where S: MutStorage,

type Completed = LESetExtendedAdvertisingParametersV1Command_EmbossReservedAnonymousField8Writer<S, CompleteState>

fn check_complete( self, ) -> Result<<LESetExtendedAdvertisingParametersV1Command_EmbossReservedAnonymousField8Writer<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LESetExtendedScanEnableCommand<S>

where S: Storage,

type Completed = LESetExtendedScanEnableCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<LESetExtendedScanEnableCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LESetExtendedScanEnableCommandWriter<S>

where S: MutStorage,

type Completed = LESetExtendedScanEnableCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LESetExtendedScanEnableCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LESetExtendedScanParametersCommand<S>

where S: Storage,

type Completed = LESetExtendedScanParametersCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<LESetExtendedScanParametersCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LESetExtendedScanParametersCommandWriter<S>

where S: MutStorage,

type Completed = LESetExtendedScanParametersCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LESetExtendedScanParametersCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LESetExtendedScanParametersCommand_EmbossReservedAnonymousField7<S>

where S: Storage,

type Completed = LESetExtendedScanParametersCommand_EmbossReservedAnonymousField7<S, CompleteState>

fn check_complete( self, ) -> Result<<LESetExtendedScanParametersCommand_EmbossReservedAnonymousField7<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LESetExtendedScanParametersCommand_EmbossReservedAnonymousField7Writer<S>

where S: MutStorage,

type Completed = LESetExtendedScanParametersCommand_EmbossReservedAnonymousField7Writer<S, CompleteState>

fn check_complete( self, ) -> Result<<LESetExtendedScanParametersCommand_EmbossReservedAnonymousField7Writer<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LESetExtendedScanParametersData<S>

where S: Storage,

type Completed = LESetExtendedScanParametersData<S, CompleteState>

fn check_complete( self, ) -> Result<<LESetExtendedScanParametersData<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LESetExtendedScanParametersDataWriter<S>

where S: MutStorage,

type Completed = LESetExtendedScanParametersDataWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LESetExtendedScanParametersDataWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LESetExtendedScanResponseDataCommand<S>

where S: Storage,

type Completed = LESetExtendedScanResponseDataCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<LESetExtendedScanResponseDataCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LESetExtendedScanResponseDataCommandWriter<S>

where S: MutStorage,

type Completed = LESetExtendedScanResponseDataCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LESetExtendedScanResponseDataCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LESetHostFeatureCommand<S>

where S: Storage,

type Completed = LESetHostFeatureCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<LESetHostFeatureCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LESetHostFeatureCommandWriter<S>

where S: MutStorage,

type Completed = LESetHostFeatureCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LESetHostFeatureCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LESetPeriodicAdvertisingSyncTransferParametersCommand<S>

where S: Storage,

type Completed = LESetPeriodicAdvertisingSyncTransferParametersCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<LESetPeriodicAdvertisingSyncTransferParametersCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LESetPeriodicAdvertisingSyncTransferParametersCommandWriter<S>

where S: MutStorage,

type Completed = LESetPeriodicAdvertisingSyncTransferParametersCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LESetPeriodicAdvertisingSyncTransferParametersCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LESetPeriodicAdvertisingSyncTransferParametersCommand_EmbossReservedAnonymousField2<S>

where S: Storage,

type Completed = LESetPeriodicAdvertisingSyncTransferParametersCommand_EmbossReservedAnonymousField2<S, CompleteState>

fn check_complete( self, ) -> Result<<LESetPeriodicAdvertisingSyncTransferParametersCommand_EmbossReservedAnonymousField2<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LESetPeriodicAdvertisingSyncTransferParametersCommand_EmbossReservedAnonymousField2Writer<S>

where S: MutStorage,

type Completed = LESetPeriodicAdvertisingSyncTransferParametersCommand_EmbossReservedAnonymousField2Writer<S, CompleteState>

fn check_complete( self, ) -> Result<<LESetPeriodicAdvertisingSyncTransferParametersCommand_EmbossReservedAnonymousField2Writer<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LESetPeriodicSyncSubeventCommand<S>

where S: Storage,

type Completed = LESetPeriodicSyncSubeventCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<LESetPeriodicSyncSubeventCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LESetPeriodicSyncSubeventCommandWriter<S>

where S: MutStorage,

type Completed = LESetPeriodicSyncSubeventCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LESetPeriodicSyncSubeventCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LESetPeriodicSyncSubeventCommand_EmbossReservedAnonymousField3<S>

where S: Storage,

type Completed = LESetPeriodicSyncSubeventCommand_EmbossReservedAnonymousField3<S, CompleteState>

fn check_complete( self, ) -> Result<<LESetPeriodicSyncSubeventCommand_EmbossReservedAnonymousField3<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LESetPeriodicSyncSubeventCommand_EmbossReservedAnonymousField3Writer<S>

where S: MutStorage,

type Completed = LESetPeriodicSyncSubeventCommand_EmbossReservedAnonymousField3Writer<S, CompleteState>

fn check_complete( self, ) -> Result<<LESetPeriodicSyncSubeventCommand_EmbossReservedAnonymousField3Writer<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LESetPrivacyModeCommand<S>

where S: Storage,

type Completed = LESetPrivacyModeCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<LESetPrivacyModeCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LESetPrivacyModeCommandWriter<S>

where S: MutStorage,

type Completed = LESetPrivacyModeCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LESetPrivacyModeCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LESetRandomAddressCommand<S>

where S: Storage,

type Completed = LESetRandomAddressCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<LESetRandomAddressCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LESetRandomAddressCommandWriter<S>

where S: MutStorage,

type Completed = LESetRandomAddressCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LESetRandomAddressCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LESetScanEnableCommand<S>

where S: Storage,

type Completed = LESetScanEnableCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<LESetScanEnableCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LESetScanEnableCommandWriter<S>

where S: MutStorage,

type Completed = LESetScanEnableCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LESetScanEnableCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LESetScanParametersCommand<S>

where S: Storage,

type Completed = LESetScanParametersCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<LESetScanParametersCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LESetScanParametersCommandWriter<S>

where S: MutStorage,

type Completed = LESetScanParametersCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LESetScanParametersCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LESetScanResponseDataCommand<S>

where S: Storage,

type Completed = LESetScanResponseDataCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<LESetScanResponseDataCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LESetScanResponseDataCommandWriter<S>

where S: MutStorage,

type Completed = LESetScanResponseDataCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LESetScanResponseDataCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LESetupISODataPathCommand<S>

where S: Storage,

type Completed = LESetupISODataPathCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<LESetupISODataPathCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LESetupISODataPathCommandWriter<S>

where S: MutStorage,

type Completed = LESetupISODataPathCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LESetupISODataPathCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEWriteRFPathCompensationCommand<S>

where S: Storage,

type Completed = LEWriteRFPathCompensationCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<LEWriteRFPathCompensationCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LEWriteRFPathCompensationCommandWriter<S>

where S: MutStorage,

type Completed = LEWriteRFPathCompensationCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LEWriteRFPathCompensationCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LinkKey<S>

where S: Storage,

type Completed = LinkKey<S, CompleteState>

fn check_complete( self, ) -> Result<<LinkKey<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LinkKeyRequestNegativeReplyCommand<S>

where S: Storage,

type Completed = LinkKeyRequestNegativeReplyCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<LinkKeyRequestNegativeReplyCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LinkKeyRequestNegativeReplyCommandWriter<S>

where S: MutStorage,

type Completed = LinkKeyRequestNegativeReplyCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LinkKeyRequestNegativeReplyCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LinkKeyRequestReplyCommand<S>

where S: Storage,

type Completed = LinkKeyRequestReplyCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<LinkKeyRequestReplyCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LinkKeyRequestReplyCommandWriter<S>

where S: MutStorage,

type Completed = LinkKeyRequestReplyCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LinkKeyRequestReplyCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LinkKeyWriter<S>

where S: MutStorage,

type Completed = LinkKeyWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LinkKeyWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LinkPolicySettings<S>

where S: Storage,

type Completed = LinkPolicySettings<S, CompleteState>

fn check_complete( self, ) -> Result<<LinkPolicySettings<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LinkPolicySettingsWriter<S>

where S: MutStorage,

type Completed = LinkPolicySettingsWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LinkPolicySettingsWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LocalName<S>

where S: Storage,

type Completed = LocalName<S, CompleteState>

fn check_complete( self, ) -> Result<<LocalName<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for LocalNameWriter<S>

where S: MutStorage,

type Completed = LocalNameWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<LocalNameWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for MajorServiceClasses<S>

where S: Storage,

type Completed = MajorServiceClasses<S, CompleteState>

fn check_complete( self, ) -> Result<<MajorServiceClasses<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for MajorServiceClassesWriter<S>

where S: MutStorage,

type Completed = MajorServiceClassesWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<MajorServiceClassesWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for OpCodeBits<S>

where S: Storage,

type Completed = OpCodeBits<S, CompleteState>

fn check_complete( self, ) -> Result<<OpCodeBits<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for OpCodeBitsWriter<S>

where S: MutStorage,

type Completed = OpCodeBitsWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<OpCodeBitsWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for PacketType<S>

where S: Storage,

type Completed = PacketType<S, CompleteState>

fn check_complete( self, ) -> Result<<PacketType<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for PacketTypeWriter<S>

where S: MutStorage,

type Completed = PacketTypeWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<PacketTypeWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for PeriodicAdvertisingProperties<S>

where S: Storage,

type Completed = PeriodicAdvertisingProperties<S, CompleteState>

fn check_complete( self, ) -> Result<<PeriodicAdvertisingProperties<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for PeriodicAdvertisingPropertiesWriter<S>

where S: MutStorage,

type Completed = PeriodicAdvertisingPropertiesWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<PeriodicAdvertisingPropertiesWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for PeripheralMinorDeviceClass<S>

where S: Storage,

type Completed = PeripheralMinorDeviceClass<S, CompleteState>

fn check_complete( self, ) -> Result<<PeripheralMinorDeviceClass<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for PeripheralMinorDeviceClassWriter<S>

where S: MutStorage,

type Completed = PeripheralMinorDeviceClassWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<PeripheralMinorDeviceClassWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for PinCodeRequestNegativeReplyCommand<S>

where S: Storage,

type Completed = PinCodeRequestNegativeReplyCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<PinCodeRequestNegativeReplyCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for PinCodeRequestNegativeReplyCommandWriter<S>

where S: MutStorage,

type Completed = PinCodeRequestNegativeReplyCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<PinCodeRequestNegativeReplyCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for PinCodeRequestReplyCommand<S>

where S: Storage,

type Completed = PinCodeRequestReplyCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<PinCodeRequestReplyCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for PinCodeRequestReplyCommandWriter<S>

where S: MutStorage,

type Completed = PinCodeRequestReplyCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<PinCodeRequestReplyCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ReadAuthenticatedPayloadTimeoutCommand<S>

where S: Storage,

type Completed = ReadAuthenticatedPayloadTimeoutCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<ReadAuthenticatedPayloadTimeoutCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ReadAuthenticatedPayloadTimeoutCommandWriter<S>

where S: MutStorage,

type Completed = ReadAuthenticatedPayloadTimeoutCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<ReadAuthenticatedPayloadTimeoutCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ReadBdAddrCommand<S>

where S: Storage,

type Completed = ReadBdAddrCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<ReadBdAddrCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ReadBdAddrCommandWriter<S>

where S: MutStorage,

type Completed = ReadBdAddrCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<ReadBdAddrCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ReadBufferSizeCommand<S>

where S: Storage,

type Completed = ReadBufferSizeCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<ReadBufferSizeCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ReadBufferSizeCommandWriter<S>

where S: MutStorage,

type Completed = ReadBufferSizeCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<ReadBufferSizeCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ReadClassOfDeviceCommand<S>

where S: Storage,

type Completed = ReadClassOfDeviceCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<ReadClassOfDeviceCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ReadClassOfDeviceCommandWriter<S>

where S: MutStorage,

type Completed = ReadClassOfDeviceCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<ReadClassOfDeviceCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ReadEncryptionKeySizeCommand<S>

where S: Storage,

type Completed = ReadEncryptionKeySizeCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<ReadEncryptionKeySizeCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ReadEncryptionKeySizeCommandWriter<S>

where S: MutStorage,

type Completed = ReadEncryptionKeySizeCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<ReadEncryptionKeySizeCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ReadFlowControlModeCommand<S>

where S: Storage,

type Completed = ReadFlowControlModeCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<ReadFlowControlModeCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ReadFlowControlModeCommandWriter<S>

where S: MutStorage,

type Completed = ReadFlowControlModeCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<ReadFlowControlModeCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ReadInquiryModeCommand<S>

where S: Storage,

type Completed = ReadInquiryModeCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<ReadInquiryModeCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ReadInquiryModeCommandWriter<S>

where S: MutStorage,

type Completed = ReadInquiryModeCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<ReadInquiryModeCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ReadInquiryScanActivityCommand<S>

where S: Storage,

type Completed = ReadInquiryScanActivityCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<ReadInquiryScanActivityCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ReadInquiryScanActivityCommandWriter<S>

where S: MutStorage,

type Completed = ReadInquiryScanActivityCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<ReadInquiryScanActivityCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ReadLEHostSupportCommand<S>

where S: Storage,

type Completed = ReadLEHostSupportCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<ReadLEHostSupportCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ReadLEHostSupportCommandWriter<S>

where S: MutStorage,

type Completed = ReadLEHostSupportCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<ReadLEHostSupportCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ReadLocalExtendedFeaturesCommand<S>

where S: Storage,

type Completed = ReadLocalExtendedFeaturesCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<ReadLocalExtendedFeaturesCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ReadLocalExtendedFeaturesCommandWriter<S>

where S: MutStorage,

type Completed = ReadLocalExtendedFeaturesCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<ReadLocalExtendedFeaturesCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ReadLocalNameCommand<S>

where S: Storage,

type Completed = ReadLocalNameCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<ReadLocalNameCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ReadLocalNameCommandWriter<S>

where S: MutStorage,

type Completed = ReadLocalNameCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<ReadLocalNameCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ReadLocalSupportedCommandsCommand<S>

where S: Storage,

type Completed = ReadLocalSupportedCommandsCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<ReadLocalSupportedCommandsCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ReadLocalSupportedCommandsCommandWriter<S>

where S: MutStorage,

type Completed = ReadLocalSupportedCommandsCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<ReadLocalSupportedCommandsCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ReadLocalSupportedControllerDelayCommand<S>

where S: Storage,

type Completed = ReadLocalSupportedControllerDelayCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<ReadLocalSupportedControllerDelayCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ReadLocalSupportedControllerDelayCommandWriter<S>

where S: MutStorage,

type Completed = ReadLocalSupportedControllerDelayCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<ReadLocalSupportedControllerDelayCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ReadLocalSupportedFeaturesCommand<S>

where S: Storage,

type Completed = ReadLocalSupportedFeaturesCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<ReadLocalSupportedFeaturesCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ReadLocalSupportedFeaturesCommandWriter<S>

where S: MutStorage,

type Completed = ReadLocalSupportedFeaturesCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<ReadLocalSupportedFeaturesCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ReadLocalVersionInformationCommand<S>

where S: Storage,

type Completed = ReadLocalVersionInformationCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<ReadLocalVersionInformationCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ReadLocalVersionInformationCommandWriter<S>

where S: MutStorage,

type Completed = ReadLocalVersionInformationCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<ReadLocalVersionInformationCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ReadPageScanActivityCommand<S>

where S: Storage,

type Completed = ReadPageScanActivityCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<ReadPageScanActivityCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ReadPageScanActivityCommandWriter<S>

where S: MutStorage,

type Completed = ReadPageScanActivityCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<ReadPageScanActivityCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ReadPageScanTypeCommand<S>

where S: Storage,

type Completed = ReadPageScanTypeCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<ReadPageScanTypeCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ReadPageScanTypeCommandWriter<S>

where S: MutStorage,

type Completed = ReadPageScanTypeCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<ReadPageScanTypeCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ReadPinTypeCommand<S>

where S: Storage,

type Completed = ReadPinTypeCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<ReadPinTypeCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ReadPinTypeCommandWriter<S>

where S: MutStorage,

type Completed = ReadPinTypeCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<ReadPinTypeCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ReadRemoteExtendedFeaturesCommand<S>

where S: Storage,

type Completed = ReadRemoteExtendedFeaturesCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<ReadRemoteExtendedFeaturesCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ReadRemoteExtendedFeaturesCommandWriter<S>

where S: MutStorage,

type Completed = ReadRemoteExtendedFeaturesCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<ReadRemoteExtendedFeaturesCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ReadRemoteSupportedFeaturesCommand<S>

where S: Storage,

type Completed = ReadRemoteSupportedFeaturesCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<ReadRemoteSupportedFeaturesCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ReadRemoteSupportedFeaturesCommandWriter<S>

where S: MutStorage,

type Completed = ReadRemoteSupportedFeaturesCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<ReadRemoteSupportedFeaturesCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ReadRemoteVersionInfoCommand<S>

where S: Storage,

type Completed = ReadRemoteVersionInfoCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<ReadRemoteVersionInfoCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ReadRemoteVersionInfoCommandWriter<S>

where S: MutStorage,

type Completed = ReadRemoteVersionInfoCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<ReadRemoteVersionInfoCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ReadRssiCommand<S>

where S: Storage,

type Completed = ReadRssiCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<ReadRssiCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ReadRssiCommandWriter<S>

where S: MutStorage,

type Completed = ReadRssiCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<ReadRssiCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ReadScanEnableCommand<S>

where S: Storage,

type Completed = ReadScanEnableCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<ReadScanEnableCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ReadScanEnableCommandWriter<S>

where S: MutStorage,

type Completed = ReadScanEnableCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<ReadScanEnableCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ReadSimplePairingModeCommand<S>

where S: Storage,

type Completed = ReadSimplePairingModeCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<ReadSimplePairingModeCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ReadSimplePairingModeCommandWriter<S>

where S: MutStorage,

type Completed = ReadSimplePairingModeCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<ReadSimplePairingModeCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for RejectConnectionRequestCommand<S>

where S: Storage,

type Completed = RejectConnectionRequestCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<RejectConnectionRequestCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for RejectConnectionRequestCommandWriter<S>

where S: MutStorage,

type Completed = RejectConnectionRequestCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<RejectConnectionRequestCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for RejectSynchronousConnectionRequestCommand<S>

where S: Storage,

type Completed = RejectSynchronousConnectionRequestCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<RejectSynchronousConnectionRequestCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for RejectSynchronousConnectionRequestCommandWriter<S>

where S: MutStorage,

type Completed = RejectSynchronousConnectionRequestCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<RejectSynchronousConnectionRequestCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for RemoteNameRequestCommand<S>

where S: Storage,

type Completed = RemoteNameRequestCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<RemoteNameRequestCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for RemoteNameRequestCommandWriter<S>

where S: MutStorage,

type Completed = RemoteNameRequestCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<RemoteNameRequestCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ResetCommand<S>

where S: Storage,

type Completed = ResetCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<ResetCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ResetCommandWriter<S>

where S: MutStorage,

type Completed = ResetCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<ResetCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ScanEnableBits<S>

where S: Storage,

type Completed = ScanEnableBits<S, CompleteState>

fn check_complete( self, ) -> Result<<ScanEnableBits<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ScanEnableBitsWriter<S>

where S: MutStorage,

type Completed = ScanEnableBitsWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<ScanEnableBitsWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ScoDataHeader<S>

where S: Storage,

type Completed = ScoDataHeader<S, CompleteState>

fn check_complete( self, ) -> Result<<ScoDataHeader<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ScoDataHeaderWriter<S>

where S: MutStorage,

type Completed = ScoDataHeaderWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<ScoDataHeaderWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ScoDataHeader_EmbossReservedAnonymousField1<S>

where S: Storage,

type Completed = ScoDataHeader_EmbossReservedAnonymousField1<S, CompleteState>

fn check_complete( self, ) -> Result<<ScoDataHeader_EmbossReservedAnonymousField1<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ScoDataHeader_EmbossReservedAnonymousField1Writer<S>

where S: MutStorage,

type Completed = ScoDataHeader_EmbossReservedAnonymousField1Writer<S, CompleteState>

fn check_complete( self, ) -> Result<<ScoDataHeader_EmbossReservedAnonymousField1Writer<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ScoPacketType<S>

where S: Storage,

type Completed = ScoPacketType<S, CompleteState>

fn check_complete( self, ) -> Result<<ScoPacketType<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for ScoPacketTypeWriter<S>

where S: MutStorage,

type Completed = ScoPacketTypeWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<ScoPacketTypeWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for SetConnectionEncryptionCommand<S>

where S: Storage,

type Completed = SetConnectionEncryptionCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<SetConnectionEncryptionCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for SetConnectionEncryptionCommandWriter<S>

where S: MutStorage,

type Completed = SetConnectionEncryptionCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<SetConnectionEncryptionCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for SetEventMaskCommand<S>

where S: Storage,

type Completed = SetEventMaskCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<SetEventMaskCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for SetEventMaskCommandWriter<S>

where S: MutStorage,

type Completed = SetEventMaskCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<SetEventMaskCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for SetEventMaskCommand_EmbossReservedAnonymousField13<S>

where S: Storage,

type Completed = SetEventMaskCommand_EmbossReservedAnonymousField13<S, CompleteState>

fn check_complete( self, ) -> Result<<SetEventMaskCommand_EmbossReservedAnonymousField13<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for SetEventMaskCommand_EmbossReservedAnonymousField13Writer<S>

where S: MutStorage,

type Completed = SetEventMaskCommand_EmbossReservedAnonymousField13Writer<S, CompleteState>

fn check_complete( self, ) -> Result<<SetEventMaskCommand_EmbossReservedAnonymousField13Writer<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for SetEventMaskPage2Command<S>

where S: Storage,

type Completed = SetEventMaskPage2Command<S, CompleteState>

fn check_complete( self, ) -> Result<<SetEventMaskPage2Command<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for SetEventMaskPage2CommandWriter<S>

where S: MutStorage,

type Completed = SetEventMaskPage2CommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<SetEventMaskPage2CommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for SetEventMaskPage2Command_EmbossReservedAnonymousField11<S>

where S: Storage,

type Completed = SetEventMaskPage2Command_EmbossReservedAnonymousField11<S, CompleteState>

fn check_complete( self, ) -> Result<<SetEventMaskPage2Command_EmbossReservedAnonymousField11<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for SetEventMaskPage2Command_EmbossReservedAnonymousField11Writer<S>

where S: MutStorage,

type Completed = SetEventMaskPage2Command_EmbossReservedAnonymousField11Writer<S, CompleteState>

fn check_complete( self, ) -> Result<<SetEventMaskPage2Command_EmbossReservedAnonymousField11Writer<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for SniffModeCommand<S>

where S: Storage,

type Completed = SniffModeCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<SniffModeCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for SniffModeCommandWriter<S>

where S: MutStorage,

type Completed = SniffModeCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<SniffModeCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for SniffSubratingCommand<S>

where S: Storage,

type Completed = SniffSubratingCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<SniffSubratingCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for SniffSubratingCommandWriter<S>

where S: MutStorage,

type Completed = SniffSubratingCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<SniffSubratingCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for SubsequentKFrame<S>

where S: Storage,

type Completed = SubsequentKFrame<S, CompleteState>

fn check_complete( self, ) -> Result<<SubsequentKFrame<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for SubsequentKFrameWriter<S>

where S: MutStorage,

type Completed = SubsequentKFrameWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<SubsequentKFrameWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for SynchronousConnectionParameters<S>

where S: Storage,

type Completed = SynchronousConnectionParameters<S, CompleteState>

fn check_complete( self, ) -> Result<<SynchronousConnectionParameters<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for SynchronousConnectionParametersWriter<S>

where S: MutStorage,

type Completed = SynchronousConnectionParametersWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<SynchronousConnectionParametersWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for SynchronousConnectionParameters_EmbossReservedAnonymousField15<S>

where S: Storage,

type Completed = SynchronousConnectionParameters_EmbossReservedAnonymousField15<S, CompleteState>

fn check_complete( self, ) -> Result<<SynchronousConnectionParameters_EmbossReservedAnonymousField15<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for SynchronousConnectionParameters_EmbossReservedAnonymousField15Writer<S>

where S: MutStorage,

type Completed = SynchronousConnectionParameters_EmbossReservedAnonymousField15Writer<S, CompleteState>

fn check_complete( self, ) -> Result<<SynchronousConnectionParameters_EmbossReservedAnonymousField15Writer<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for SynchronousConnectionParameters_VendorCodingFormat<S>

where S: Storage,

type Completed = SynchronousConnectionParameters_VendorCodingFormat<S, CompleteState>

fn check_complete( self, ) -> Result<<SynchronousConnectionParameters_VendorCodingFormat<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for SynchronousConnectionParameters_VendorCodingFormatWriter<S>

where S: MutStorage,

type Completed = SynchronousConnectionParameters_VendorCodingFormatWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<SynchronousConnectionParameters_VendorCodingFormatWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for UserConfirmationRequestNegativeReplyCommand<S>

where S: Storage,

type Completed = UserConfirmationRequestNegativeReplyCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<UserConfirmationRequestNegativeReplyCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for UserConfirmationRequestNegativeReplyCommandWriter<S>

where S: MutStorage,

type Completed = UserConfirmationRequestNegativeReplyCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<UserConfirmationRequestNegativeReplyCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for UserConfirmationRequestReplyCommand<S>

where S: Storage,

type Completed = UserConfirmationRequestReplyCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<UserConfirmationRequestReplyCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for UserConfirmationRequestReplyCommandWriter<S>

where S: MutStorage,

type Completed = UserConfirmationRequestReplyCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<UserConfirmationRequestReplyCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for UserPasskeyRequestNegativeReplyCommand<S>

where S: Storage,

type Completed = UserPasskeyRequestNegativeReplyCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<UserPasskeyRequestNegativeReplyCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for UserPasskeyRequestNegativeReplyCommandWriter<S>

where S: MutStorage,

type Completed = UserPasskeyRequestNegativeReplyCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<UserPasskeyRequestNegativeReplyCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for UserPasskeyRequestReplyCommand<S>

where S: Storage,

type Completed = UserPasskeyRequestReplyCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<UserPasskeyRequestReplyCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for UserPasskeyRequestReplyCommandWriter<S>

where S: MutStorage,

type Completed = UserPasskeyRequestReplyCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<UserPasskeyRequestReplyCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for VendorDebugEvent<S>

where S: Storage,

type Completed = VendorDebugEvent<S, CompleteState>

fn check_complete( self, ) -> Result<<VendorDebugEvent<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for VendorDebugEventWriter<S>

where S: MutStorage,

type Completed = VendorDebugEventWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<VendorDebugEventWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for WriteAuthenticatedPayloadTimeoutCommand<S>

where S: Storage,

type Completed = WriteAuthenticatedPayloadTimeoutCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<WriteAuthenticatedPayloadTimeoutCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for WriteAuthenticatedPayloadTimeoutCommandWriter<S>

where S: MutStorage,

type Completed = WriteAuthenticatedPayloadTimeoutCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<WriteAuthenticatedPayloadTimeoutCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for WriteAutomaticFlushTimeoutCommand<S>

where S: Storage,

type Completed = WriteAutomaticFlushTimeoutCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<WriteAutomaticFlushTimeoutCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for WriteAutomaticFlushTimeoutCommandWriter<S>

where S: MutStorage,

type Completed = WriteAutomaticFlushTimeoutCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<WriteAutomaticFlushTimeoutCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for WriteClassOfDeviceCommand<S>

where S: Storage,

type Completed = WriteClassOfDeviceCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<WriteClassOfDeviceCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for WriteClassOfDeviceCommandWriter<S>

where S: MutStorage,

type Completed = WriteClassOfDeviceCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<WriteClassOfDeviceCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for WriteDefaultLinkPolicySettingsCommand<S>

where S: Storage,

type Completed = WriteDefaultLinkPolicySettingsCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<WriteDefaultLinkPolicySettingsCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for WriteDefaultLinkPolicySettingsCommandWriter<S>

where S: MutStorage,

type Completed = WriteDefaultLinkPolicySettingsCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<WriteDefaultLinkPolicySettingsCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for WriteDefaultLinkPolicySettingsCommand_EmbossReservedAnonymousField14<S>

where S: Storage,

type Completed = WriteDefaultLinkPolicySettingsCommand_EmbossReservedAnonymousField14<S, CompleteState>

fn check_complete( self, ) -> Result<<WriteDefaultLinkPolicySettingsCommand_EmbossReservedAnonymousField14<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for WriteDefaultLinkPolicySettingsCommand_EmbossReservedAnonymousField14Writer<S>

where S: MutStorage,

type Completed = WriteDefaultLinkPolicySettingsCommand_EmbossReservedAnonymousField14Writer<S, CompleteState>

fn check_complete( self, ) -> Result<<WriteDefaultLinkPolicySettingsCommand_EmbossReservedAnonymousField14Writer<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for WriteExtendedInquiryResponseCommand<S>

where S: Storage,

type Completed = WriteExtendedInquiryResponseCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<WriteExtendedInquiryResponseCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for WriteExtendedInquiryResponseCommandWriter<S>

where S: MutStorage,

type Completed = WriteExtendedInquiryResponseCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<WriteExtendedInquiryResponseCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for WriteFlowControlModeCommand<S>

where S: Storage,

type Completed = WriteFlowControlModeCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<WriteFlowControlModeCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for WriteFlowControlModeCommandWriter<S>

where S: MutStorage,

type Completed = WriteFlowControlModeCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<WriteFlowControlModeCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for WriteInquiryModeCommand<S>

where S: Storage,

type Completed = WriteInquiryModeCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<WriteInquiryModeCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for WriteInquiryModeCommandWriter<S>

where S: MutStorage,

type Completed = WriteInquiryModeCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<WriteInquiryModeCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for WriteInquiryScanActivityCommand<S>

where S: Storage,

type Completed = WriteInquiryScanActivityCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<WriteInquiryScanActivityCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for WriteInquiryScanActivityCommandWriter<S>

where S: MutStorage,

type Completed = WriteInquiryScanActivityCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<WriteInquiryScanActivityCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for WriteInquiryScanTypeCommand<S>

where S: Storage,

type Completed = WriteInquiryScanTypeCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<WriteInquiryScanTypeCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for WriteInquiryScanTypeCommandWriter<S>

where S: MutStorage,

type Completed = WriteInquiryScanTypeCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<WriteInquiryScanTypeCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for WriteLEHostSupportCommand<S>

where S: Storage,

type Completed = WriteLEHostSupportCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<WriteLEHostSupportCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for WriteLEHostSupportCommandWriter<S>

where S: MutStorage,

type Completed = WriteLEHostSupportCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<WriteLEHostSupportCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for WriteLocalNameCommand<S>

where S: Storage,

type Completed = WriteLocalNameCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<WriteLocalNameCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for WriteLocalNameCommandWriter<S>

where S: MutStorage,

type Completed = WriteLocalNameCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<WriteLocalNameCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for WritePageScanActivityCommand<S>

where S: Storage,

type Completed = WritePageScanActivityCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<WritePageScanActivityCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for WritePageScanActivityCommandWriter<S>

where S: MutStorage,

type Completed = WritePageScanActivityCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<WritePageScanActivityCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for WritePageScanTypeCommand<S>

where S: Storage,

type Completed = WritePageScanTypeCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<WritePageScanTypeCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for WritePageScanTypeCommandWriter<S>

where S: MutStorage,

type Completed = WritePageScanTypeCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<WritePageScanTypeCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for WritePageTimeoutCommand<S>

where S: Storage,

type Completed = WritePageTimeoutCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<WritePageTimeoutCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for WritePageTimeoutCommandWriter<S>

where S: MutStorage,

type Completed = WritePageTimeoutCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<WritePageTimeoutCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for WritePinTypeCommand<S>

where S: Storage,

type Completed = WritePinTypeCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<WritePinTypeCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for WritePinTypeCommandWriter<S>

where S: MutStorage,

type Completed = WritePinTypeCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<WritePinTypeCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for WriteScanEnableCommand<S>

where S: Storage,

type Completed = WriteScanEnableCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<WriteScanEnableCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for WriteScanEnableCommandWriter<S>

where S: MutStorage,

type Completed = WriteScanEnableCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<WriteScanEnableCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for WriteScanEnableCommand_EmbossReservedAnonymousField12<S>

where S: Storage,

type Completed = WriteScanEnableCommand_EmbossReservedAnonymousField12<S, CompleteState>

fn check_complete( self, ) -> Result<<WriteScanEnableCommand_EmbossReservedAnonymousField12<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for WriteScanEnableCommand_EmbossReservedAnonymousField12Writer<S>

where S: MutStorage,

type Completed = WriteScanEnableCommand_EmbossReservedAnonymousField12Writer<S, CompleteState>

fn check_complete( self, ) -> Result<<WriteScanEnableCommand_EmbossReservedAnonymousField12Writer<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for WriteSecureConnectionsHostSupportCommand<S>

where S: Storage,

type Completed = WriteSecureConnectionsHostSupportCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<WriteSecureConnectionsHostSupportCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for WriteSecureConnectionsHostSupportCommandWriter<S>

where S: MutStorage,

type Completed = WriteSecureConnectionsHostSupportCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<WriteSecureConnectionsHostSupportCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for WriteSimplePairingDebugModeCommand<S>

where S: Storage,

type Completed = WriteSimplePairingDebugModeCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<WriteSimplePairingDebugModeCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for WriteSimplePairingDebugModeCommandWriter<S>

where S: MutStorage,

type Completed = WriteSimplePairingDebugModeCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<WriteSimplePairingDebugModeCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for WriteSimplePairingModeCommand<S>

where S: Storage,

type Completed = WriteSimplePairingModeCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<WriteSimplePairingModeCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for WriteSimplePairingModeCommandWriter<S>

where S: MutStorage,

type Completed = WriteSimplePairingModeCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<WriteSimplePairingModeCommandWriter<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for WriteSynchronousFlowControlEnableCommand<S>

where S: Storage,

type Completed = WriteSynchronousFlowControlEnableCommand<S, CompleteState>

fn check_complete( self, ) -> Result<<WriteSynchronousFlowControlEnableCommand<S> as CheckComplete>::Completed, Error>

impl<S> CheckComplete for WriteSynchronousFlowControlEnableCommandWriter<S>

where S: MutStorage,

type Completed = WriteSynchronousFlowControlEnableCommandWriter<S, CompleteState>

fn check_complete( self, ) -> Result<<WriteSynchronousFlowControlEnableCommandWriter<S> as CheckComplete>::Completed, Error>

Implementors