Skip to main content

ControllerFeatures

inputflow::api_traits::cglue_controllerfeatures

Struct ControllerFeatures 

Source 
pub struct ControllerFeatures<'cglue_a, CGlueInst: 'cglue_a, CGlueCtx: ContextBounds>
where
    ControllerFeaturesContainer<CGlueInst, CGlueCtx>: CGlueObjBase,
{ /* private fields */ }
Expand description

Trait group potentially implementing Loadable < > + :: cglue :: ext :: core :: clone :: Clone < > + KeyboardWriter < > + MouseWriter < > traits.

Optional traits are not implemented here, however. There are numerous conversion functions available for safely retrieving a concrete collection of traits.

check_impl_ functions allow to check if the object implements the wanted traits.

into_impl_ functions consume the object and produce a new final structure that keeps only the required information.

cast_impl_ functions merely check and transform the object into a type that can be transformed back into ControllerFeatures without losing data.

as_ref_, and as_mut_ functions obtain references to safe objects, but do not perform any memory transformations either. They are the safest to use, because there is no risk of accidentally consuming the whole object.

Implementations§

Source§

impl<'cglue_a, CGlueInst, CGlueCtx: ContextBounds> ControllerFeatures<'cglue_a, CGlueInst, CGlueCtx>
where ControllerFeaturesContainer<CGlueInst, CGlueCtx>: CGlueObjBase,

Source

pub fn enable_clone(self) -> Self
where &'cglue_a CloneVtbl<'cglue_a, ControllerFeaturesContainer<CGlueInst, CGlueCtx>>: Default,

Source

pub fn enable_keyboardwriter(self) -> Self
where &'cglue_a KeyboardWriterVtbl<'cglue_a, ControllerFeaturesContainer<CGlueInst, CGlueCtx>>: Default,

Source

pub fn enable_mousewriter(self) -> Self
where &'cglue_a MouseWriterVtbl<'cglue_a, ControllerFeaturesContainer<CGlueInst, CGlueCtx>>: Default,

Source§

impl<'cglue_a, CGlueInst, CGlueCtx: ContextBounds> ControllerFeatures<'cglue_a, CGlueInst, CGlueCtx>
where ControllerFeaturesContainer<CGlueInst, CGlueCtx>: CGlueObjBase, &'cglue_a LoadableVtbl<'cglue_a, ControllerFeaturesContainer<CGlueInst, CGlueCtx>>: 'cglue_a + Default,

Source

pub fn new( instance: CGlueInst, context: CGlueCtx, vtbl_clone: Option<&'cglue_a CloneVtbl<'cglue_a, ControllerFeaturesContainer<CGlueInst, CGlueCtx>>>, vtbl_keyboardwriter: Option<&'cglue_a KeyboardWriterVtbl<'cglue_a, ControllerFeaturesContainer<CGlueInst, CGlueCtx>>>, vtbl_mousewriter: Option<&'cglue_a MouseWriterVtbl<'cglue_a, ControllerFeaturesContainer<CGlueInst, CGlueCtx>>>, ) -> Self
where &'cglue_a LoadableVtbl<'cglue_a, ControllerFeaturesContainer<CGlueInst, CGlueCtx>>: 'cglue_a + Default,

Create new instance of ControllerFeatures.

Source§

impl<'cglue_a, CGlueT> ControllerFeatures<'cglue_a, CBox<'cglue_a, CGlueT>, NoContext>

Source

pub fn new_boxed( this: CGlueT, vtbl_clone: Option<&'cglue_a CloneVtbl<'cglue_a, ControllerFeaturesContainer<CBox<'cglue_a, CGlueT>, NoContext>>>, vtbl_keyboardwriter: Option<&'cglue_a KeyboardWriterVtbl<'cglue_a, ControllerFeaturesContainer<CBox<'cglue_a, CGlueT>, NoContext>>>, vtbl_mousewriter: Option<&'cglue_a MouseWriterVtbl<'cglue_a, ControllerFeaturesContainer<CBox<'cglue_a, CGlueT>, NoContext>>>, ) -> Self
where &'cglue_a LoadableVtbl<'cglue_a, ControllerFeaturesContainer<CBox<'cglue_a, CGlueT>, NoContext>>: 'cglue_a + Default,

Create new instance of ControllerFeatures.

instance will be moved onto heap.

Source§

impl<'cglue_a, CGlueInst, CGlueCtx: ContextBounds> ControllerFeatures<'cglue_a, CGlueInst, CGlueCtx>
where ControllerFeaturesContainer<CGlueInst, CGlueCtx>: CGlueObjBase,

Source

pub fn check_impl_clone(&self) -> bool
where ControllerFeaturesWithClone<'cglue_a, CGlueInst, CGlueCtx>: 'cglue_a + Loadable + Clone,

Check whether ControllerFeatures implements Loadable < > + :: cglue :: ext :: core :: clone :: Clone < >.

If this check returns true, it is safe to run consuming conversion operations.

Source

pub fn into_impl_clone(self) -> Option<impl 'cglue_a + Loadable + Clone>
where ControllerFeaturesFinalWithClone<'cglue_a, CGlueInst, CGlueCtx>: 'cglue_a + Loadable + Clone,

Retrieve a final ControllerFeatures variant that implements Loadable < > + :: cglue :: ext :: core :: clone :: Clone < >.

This consumes the ControllerFeatures, and outputs Some(impl Loadable < > + :: cglue :: ext :: core :: clone :: Clone < >), if all types are present.

Source

pub fn cast_impl_clone( self, ) -> Option<ControllerFeaturesWithClone<'cglue_a, CGlueInst, CGlueCtx>>
where ControllerFeaturesWithClone<'cglue_a, CGlueInst, CGlueCtx>: 'cglue_a + Loadable + Clone,

Retrieve a concrete ControllerFeatures variant that implements Loadable < > + :: cglue :: ext :: core :: clone :: Clone < >.

This consumes the ControllerFeatures, and outputs Some(impl Loadable < > + :: cglue :: ext :: core :: clone :: Clone < >), if all types are present. It is possible to cast this type back with the From implementation.

Source

pub fn as_mut_impl_clone<'b>( &'b mut self, ) -> Option<&'b mut (impl 'cglue_a + Loadable + Clone)>
where ControllerFeaturesWithClone<'cglue_a, CGlueInst, CGlueCtx>: 'cglue_a + Loadable + Clone,

Retrieve mutable reference to a concrete ControllerFeatures variant that implements Loadable < > + :: cglue :: ext :: core :: clone :: Clone < >.

Source

pub fn as_ref_impl_clone<'b>( &'b self, ) -> Option<&'b (impl 'cglue_a + Loadable + Clone)>
where ControllerFeaturesWithClone<'cglue_a, CGlueInst, CGlueCtx>: 'cglue_a + Loadable + Clone,

Retrieve immutable reference to a concrete ControllerFeatures variant that implements Loadable < > + :: cglue :: ext :: core :: clone :: Clone < >.

Source

pub fn check_impl_keyboardwriter(&self) -> bool
where ControllerFeaturesWithKeyboardWriter<'cglue_a, CGlueInst, CGlueCtx>: 'cglue_a + Loadable + KeyboardWriter,

Check whether ControllerFeatures implements Loadable < > + KeyboardWriter < >.

If this check returns true, it is safe to run consuming conversion operations.

Source

pub fn into_impl_keyboardwriter( self, ) -> Option<impl 'cglue_a + Loadable + KeyboardWriter>
where ControllerFeaturesFinalWithKeyboardWriter<'cglue_a, CGlueInst, CGlueCtx>: 'cglue_a + Loadable + KeyboardWriter,

Retrieve a final ControllerFeatures variant that implements Loadable < > + KeyboardWriter < >.

This consumes the ControllerFeatures, and outputs Some(impl Loadable < > + KeyboardWriter < >), if all types are present.

Source

pub fn cast_impl_keyboardwriter( self, ) -> Option<ControllerFeaturesWithKeyboardWriter<'cglue_a, CGlueInst, CGlueCtx>>
where ControllerFeaturesWithKeyboardWriter<'cglue_a, CGlueInst, CGlueCtx>: 'cglue_a + Loadable + KeyboardWriter,

Retrieve a concrete ControllerFeatures variant that implements Loadable < > + KeyboardWriter < >.

This consumes the ControllerFeatures, and outputs Some(impl Loadable < > + KeyboardWriter < >), if all types are present. It is possible to cast this type back with the From implementation.

Source

pub fn as_mut_impl_keyboardwriter<'b>( &'b mut self, ) -> Option<&'b mut (impl 'cglue_a + Loadable + KeyboardWriter)>
where ControllerFeaturesWithKeyboardWriter<'cglue_a, CGlueInst, CGlueCtx>: 'cglue_a + Loadable + KeyboardWriter,

Retrieve mutable reference to a concrete ControllerFeatures variant that implements Loadable < > + KeyboardWriter < >.

Source

pub fn as_ref_impl_keyboardwriter<'b>( &'b self, ) -> Option<&'b (impl 'cglue_a + Loadable + KeyboardWriter)>
where ControllerFeaturesWithKeyboardWriter<'cglue_a, CGlueInst, CGlueCtx>: 'cglue_a + Loadable + KeyboardWriter,

Retrieve immutable reference to a concrete ControllerFeatures variant that implements Loadable < > + KeyboardWriter < >.

Source

pub fn check_impl_mousewriter(&self) -> bool
where ControllerFeaturesWithMouseWriter<'cglue_a, CGlueInst, CGlueCtx>: 'cglue_a + Loadable + MouseWriter,

Check whether ControllerFeatures implements Loadable < > + MouseWriter < >.

If this check returns true, it is safe to run consuming conversion operations.

Source

pub fn into_impl_mousewriter( self, ) -> Option<impl 'cglue_a + Loadable + MouseWriter>
where ControllerFeaturesFinalWithMouseWriter<'cglue_a, CGlueInst, CGlueCtx>: 'cglue_a + Loadable + MouseWriter,

Retrieve a final ControllerFeatures variant that implements Loadable < > + MouseWriter < >.

This consumes the ControllerFeatures, and outputs Some(impl Loadable < > + MouseWriter < >), if all types are present.

Source

pub fn cast_impl_mousewriter( self, ) -> Option<ControllerFeaturesWithMouseWriter<'cglue_a, CGlueInst, CGlueCtx>>
where ControllerFeaturesWithMouseWriter<'cglue_a, CGlueInst, CGlueCtx>: 'cglue_a + Loadable + MouseWriter,

Retrieve a concrete ControllerFeatures variant that implements Loadable < > + MouseWriter < >.

This consumes the ControllerFeatures, and outputs Some(impl Loadable < > + MouseWriter < >), if all types are present. It is possible to cast this type back with the From implementation.

Source

pub fn as_mut_impl_mousewriter<'b>( &'b mut self, ) -> Option<&'b mut (impl 'cglue_a + Loadable + MouseWriter)>
where ControllerFeaturesWithMouseWriter<'cglue_a, CGlueInst, CGlueCtx>: 'cglue_a + Loadable + MouseWriter,

Retrieve mutable reference to a concrete ControllerFeatures variant that implements Loadable < > + MouseWriter < >.

Source

pub fn as_ref_impl_mousewriter<'b>( &'b self, ) -> Option<&'b (impl 'cglue_a + Loadable + MouseWriter)>
where ControllerFeaturesWithMouseWriter<'cglue_a, CGlueInst, CGlueCtx>: 'cglue_a + Loadable + MouseWriter,

Retrieve immutable reference to a concrete ControllerFeatures variant that implements Loadable < > + MouseWriter < >.

Source

pub fn check_impl_clone_keyboardwriter(&self) -> bool
where ControllerFeaturesWithCloneKeyboardWriter<'cglue_a, CGlueInst, CGlueCtx>: 'cglue_a + Loadable + Clone + KeyboardWriter,

Check whether ControllerFeatures implements Loadable < > + :: cglue :: ext :: core :: clone :: Clone < > + KeyboardWriter < >.

If this check returns true, it is safe to run consuming conversion operations.

Source

pub fn into_impl_clone_keyboardwriter( self, ) -> Option<impl 'cglue_a + Loadable + Clone + KeyboardWriter>
where ControllerFeaturesFinalWithCloneKeyboardWriter<'cglue_a, CGlueInst, CGlueCtx>: 'cglue_a + Loadable + Clone + KeyboardWriter,

Retrieve a final ControllerFeatures variant that implements Loadable < > + :: cglue :: ext :: core :: clone :: Clone < > + KeyboardWriter < >.

This consumes the ControllerFeatures, and outputs Some(impl Loadable < > + :: cglue :: ext :: core :: clone :: Clone < > + KeyboardWriter < >), if all types are present.

Source

pub fn cast_impl_clone_keyboardwriter( self, ) -> Option<ControllerFeaturesWithCloneKeyboardWriter<'cglue_a, CGlueInst, CGlueCtx>>
where ControllerFeaturesWithCloneKeyboardWriter<'cglue_a, CGlueInst, CGlueCtx>: 'cglue_a + Loadable + Clone + KeyboardWriter,

Retrieve a concrete ControllerFeatures variant that implements Loadable < > + :: cglue :: ext :: core :: clone :: Clone < > + KeyboardWriter < >.

This consumes the ControllerFeatures, and outputs Some(impl Loadable < > + :: cglue :: ext :: core :: clone :: Clone < > + KeyboardWriter < >), if all types are present. It is possible to cast this type back with the From implementation.

Source

pub fn as_mut_impl_clone_keyboardwriter<'b>( &'b mut self, ) -> Option<&'b mut (impl 'cglue_a + Loadable + Clone + KeyboardWriter)>
where ControllerFeaturesWithCloneKeyboardWriter<'cglue_a, CGlueInst, CGlueCtx>: 'cglue_a + Loadable + Clone + KeyboardWriter,

Retrieve mutable reference to a concrete ControllerFeatures variant that implements Loadable < > + :: cglue :: ext :: core :: clone :: Clone < > + KeyboardWriter < >.

Source

pub fn as_ref_impl_clone_keyboardwriter<'b>( &'b self, ) -> Option<&'b (impl 'cglue_a + Loadable + Clone + KeyboardWriter)>
where ControllerFeaturesWithCloneKeyboardWriter<'cglue_a, CGlueInst, CGlueCtx>: 'cglue_a + Loadable + Clone + KeyboardWriter,

Retrieve immutable reference to a concrete ControllerFeatures variant that implements Loadable < > + :: cglue :: ext :: core :: clone :: Clone < > + KeyboardWriter < >.

Source

pub fn check_impl_clone_mousewriter(&self) -> bool
where ControllerFeaturesWithCloneMouseWriter<'cglue_a, CGlueInst, CGlueCtx>: 'cglue_a + Loadable + Clone + MouseWriter,

Check whether ControllerFeatures implements Loadable < > + :: cglue :: ext :: core :: clone :: Clone < > + MouseWriter < >.

If this check returns true, it is safe to run consuming conversion operations.

Source

pub fn into_impl_clone_mousewriter( self, ) -> Option<impl 'cglue_a + Loadable + Clone + MouseWriter>
where ControllerFeaturesFinalWithCloneMouseWriter<'cglue_a, CGlueInst, CGlueCtx>: 'cglue_a + Loadable + Clone + MouseWriter,

Retrieve a final ControllerFeatures variant that implements Loadable < > + :: cglue :: ext :: core :: clone :: Clone < > + MouseWriter < >.

This consumes the ControllerFeatures, and outputs Some(impl Loadable < > + :: cglue :: ext :: core :: clone :: Clone < > + MouseWriter < >), if all types are present.

Source

pub fn cast_impl_clone_mousewriter( self, ) -> Option<ControllerFeaturesWithCloneMouseWriter<'cglue_a, CGlueInst, CGlueCtx>>
where ControllerFeaturesWithCloneMouseWriter<'cglue_a, CGlueInst, CGlueCtx>: 'cglue_a + Loadable + Clone + MouseWriter,

Retrieve a concrete ControllerFeatures variant that implements Loadable < > + :: cglue :: ext :: core :: clone :: Clone < > + MouseWriter < >.

This consumes the ControllerFeatures, and outputs Some(impl Loadable < > + :: cglue :: ext :: core :: clone :: Clone < > + MouseWriter < >), if all types are present. It is possible to cast this type back with the From implementation.

Source

pub fn as_mut_impl_clone_mousewriter<'b>( &'b mut self, ) -> Option<&'b mut (impl 'cglue_a + Loadable + Clone + MouseWriter)>
where ControllerFeaturesWithCloneMouseWriter<'cglue_a, CGlueInst, CGlueCtx>: 'cglue_a + Loadable + Clone + MouseWriter,

Retrieve mutable reference to a concrete ControllerFeatures variant that implements Loadable < > + :: cglue :: ext :: core :: clone :: Clone < > + MouseWriter < >.

Source

pub fn as_ref_impl_clone_mousewriter<'b>( &'b self, ) -> Option<&'b (impl 'cglue_a + Loadable + Clone + MouseWriter)>
where ControllerFeaturesWithCloneMouseWriter<'cglue_a, CGlueInst, CGlueCtx>: 'cglue_a + Loadable + Clone + MouseWriter,

Retrieve immutable reference to a concrete ControllerFeatures variant that implements Loadable < > + :: cglue :: ext :: core :: clone :: Clone < > + MouseWriter < >.

Source

pub fn check_impl_keyboardwriter_mousewriter(&self) -> bool
where ControllerFeaturesWithKeyboardWriterMouseWriter<'cglue_a, CGlueInst, CGlueCtx>: 'cglue_a + Loadable + KeyboardWriter + MouseWriter,

Check whether ControllerFeatures implements Loadable < > + KeyboardWriter < > + MouseWriter < >.

If this check returns true, it is safe to run consuming conversion operations.

Source

pub fn into_impl_keyboardwriter_mousewriter( self, ) -> Option<impl 'cglue_a + Loadable + KeyboardWriter + MouseWriter>
where ControllerFeaturesFinalWithKeyboardWriterMouseWriter<'cglue_a, CGlueInst, CGlueCtx>: 'cglue_a + Loadable + KeyboardWriter + MouseWriter,

Retrieve a final ControllerFeatures variant that implements Loadable < > + KeyboardWriter < > + MouseWriter < >.

This consumes the ControllerFeatures, and outputs Some(impl Loadable < > + KeyboardWriter < > + MouseWriter < >), if all types are present.

Source

pub fn cast_impl_keyboardwriter_mousewriter( self, ) -> Option<ControllerFeaturesWithKeyboardWriterMouseWriter<'cglue_a, CGlueInst, CGlueCtx>>
where ControllerFeaturesWithKeyboardWriterMouseWriter<'cglue_a, CGlueInst, CGlueCtx>: 'cglue_a + Loadable + KeyboardWriter + MouseWriter,

Retrieve a concrete ControllerFeatures variant that implements Loadable < > + KeyboardWriter < > + MouseWriter < >.

This consumes the ControllerFeatures, and outputs Some(impl Loadable < > + KeyboardWriter < > + MouseWriter < >), if all types are present. It is possible to cast this type back with the From implementation.

Source

pub fn as_mut_impl_keyboardwriter_mousewriter<'b>( &'b mut self, ) -> Option<&'b mut (impl 'cglue_a + Loadable + KeyboardWriter + MouseWriter)>
where ControllerFeaturesWithKeyboardWriterMouseWriter<'cglue_a, CGlueInst, CGlueCtx>: 'cglue_a + Loadable + KeyboardWriter + MouseWriter,

Retrieve mutable reference to a concrete ControllerFeatures variant that implements Loadable < > + KeyboardWriter < > + MouseWriter < >.

Source

pub fn as_ref_impl_keyboardwriter_mousewriter<'b>( &'b self, ) -> Option<&'b (impl 'cglue_a + Loadable + KeyboardWriter + MouseWriter)>
where ControllerFeaturesWithKeyboardWriterMouseWriter<'cglue_a, CGlueInst, CGlueCtx>: 'cglue_a + Loadable + KeyboardWriter + MouseWriter,

Retrieve immutable reference to a concrete ControllerFeatures variant that implements Loadable < > + KeyboardWriter < > + MouseWriter < >.

Source

pub fn check_impl_clone_keyboardwriter_mousewriter(&self) -> bool
where ControllerFeaturesWithCloneKeyboardWriterMouseWriter<'cglue_a, CGlueInst, CGlueCtx>: 'cglue_a + Loadable + Clone + KeyboardWriter + MouseWriter,

Check whether ControllerFeatures implements Loadable < > + :: cglue :: ext :: core :: clone :: Clone < > + KeyboardWriter < > + MouseWriter < >.

If this check returns true, it is safe to run consuming conversion operations.

Source

pub fn into_impl_clone_keyboardwriter_mousewriter( self, ) -> Option<impl 'cglue_a + Loadable + Clone + KeyboardWriter + MouseWriter>
where ControllerFeaturesFinalWithCloneKeyboardWriterMouseWriter<'cglue_a, CGlueInst, CGlueCtx>: 'cglue_a + Loadable + Clone + KeyboardWriter + MouseWriter,

Retrieve a final ControllerFeatures variant that implements Loadable < > + :: cglue :: ext :: core :: clone :: Clone < > + KeyboardWriter < > + MouseWriter < >.

This consumes the ControllerFeatures, and outputs Some(impl Loadable < > + :: cglue :: ext :: core :: clone :: Clone < > + KeyboardWriter < > + MouseWriter < >), if all types are present.

Source

pub fn cast_impl_clone_keyboardwriter_mousewriter( self, ) -> Option<ControllerFeaturesWithCloneKeyboardWriterMouseWriter<'cglue_a, CGlueInst, CGlueCtx>>
where ControllerFeaturesWithCloneKeyboardWriterMouseWriter<'cglue_a, CGlueInst, CGlueCtx>: 'cglue_a + Loadable + Clone + KeyboardWriter + MouseWriter,

Retrieve a concrete ControllerFeatures variant that implements Loadable < > + :: cglue :: ext :: core :: clone :: Clone < > + KeyboardWriter < > + MouseWriter < >.

This consumes the ControllerFeatures, and outputs Some(impl Loadable < > + :: cglue :: ext :: core :: clone :: Clone < > + KeyboardWriter < > + MouseWriter < >), if all types are present. It is possible to cast this type back with the From implementation.

Source

pub fn as_mut_impl_clone_keyboardwriter_mousewriter<'b>( &'b mut self, ) -> Option<&'b mut (impl 'cglue_a + Loadable + Clone + KeyboardWriter + MouseWriter)>
where ControllerFeaturesWithCloneKeyboardWriterMouseWriter<'cglue_a, CGlueInst, CGlueCtx>: 'cglue_a + Loadable + Clone + KeyboardWriter + MouseWriter,

Retrieve mutable reference to a concrete ControllerFeatures variant that implements Loadable < > + :: cglue :: ext :: core :: clone :: Clone < > + KeyboardWriter < > + MouseWriter < >.

Source

pub fn as_ref_impl_clone_keyboardwriter_mousewriter<'b>( &'b self, ) -> Option<&'b (impl 'cglue_a + Loadable + Clone + KeyboardWriter + MouseWriter)>
where ControllerFeaturesWithCloneKeyboardWriterMouseWriter<'cglue_a, CGlueInst, CGlueCtx>: 'cglue_a + Loadable + Clone + KeyboardWriter + MouseWriter,

Retrieve immutable reference to a concrete ControllerFeatures variant that implements Loadable < > + :: cglue :: ext :: core :: clone :: Clone < > + KeyboardWriter < > + MouseWriter < >.

Trait Implementations§

Source§

impl<'cglue_a, CGlueInst: Deref, CGlueCtx: ContextBounds> From<(CGlueInst, CGlueCtx)> for ControllerFeatures<'cglue_a, CGlueInst, CGlueCtx>
where Self: From<ControllerFeaturesContainer<CGlueInst, CGlueCtx>>, ControllerFeaturesContainer<CGlueInst, CGlueCtx>: CGlueObjBase, &'cglue_a LoadableVtbl<'cglue_a, ControllerFeaturesContainer<CGlueInst, CGlueCtx>>: 'cglue_a + Default,

Source§

fn from((instance, context): (CGlueInst, CGlueCtx)) -> Self

Converts to this type from the input type.
Source§

impl<'cglue_a, CGlueT, CGlueCtx: ContextBounds> From<(CGlueT, CGlueCtx)> for ControllerFeatures<'cglue_a, CBox<'cglue_a, CGlueT>, CGlueCtx>
where Self: From<(CBox<'cglue_a, CGlueT>, CGlueCtx)>, ControllerFeaturesContainer<CBox<'cglue_a, CGlueT>, CGlueCtx>: CGlueObjBase, &'cglue_a LoadableVtbl<'cglue_a, ControllerFeaturesContainer<CBox<'cglue_a, CGlueT>, CGlueCtx>>: 'cglue_a + Default,

Source§

fn from((this, context): (CGlueT, CGlueCtx)) -> Self

Converts to this type from the input type.
Source§

impl<'cglue_a, CGlueInst: Deref> From<CGlueInst> for ControllerFeatures<'cglue_a, CGlueInst, NoContext>
where Self: From<(CGlueInst, NoContext)>, ControllerFeaturesContainer<CGlueInst, NoContext>: CGlueObjBase, &'cglue_a LoadableVtbl<'cglue_a, ControllerFeaturesContainer<CGlueInst, NoContext>>: 'cglue_a + Default,

Source§

fn from(instance: CGlueInst) -> Self

Converts to this type from the input type.
Source§

impl<'cglue_a, CGlueT> From<CGlueT> for ControllerFeatures<'cglue_a, CBox<'cglue_a, CGlueT>, NoContext>
where Self: From<(CBox<'cglue_a, CGlueT>, NoContext)>, &'cglue_a LoadableVtbl<'cglue_a, ControllerFeaturesContainer<CBox<'cglue_a, CGlueT>, NoContext>>: 'cglue_a + Default,

Source§

fn from(instance: CGlueT) -> Self

Converts to this type from the input type.
Source§

impl<'cglue_a, CGlueInst: Deref, CGlueCtx: ContextBounds> From<ControllerFeaturesContainer<CGlueInst, CGlueCtx>> for ControllerFeatures<'cglue_a, CGlueInst, CGlueCtx>
where ControllerFeaturesContainer<CGlueInst, CGlueCtx>: CGlueObjBase, CGlueInst::Target: ControllerFeaturesVtableFiller<'cglue_a, CGlueInst, CGlueCtx>, &'cglue_a LoadableVtbl<'cglue_a, ControllerFeaturesContainer<CGlueInst, CGlueCtx>>: 'cglue_a + Default,

Source§

fn from(container: ControllerFeaturesContainer<CGlueInst, CGlueCtx>) -> Self

Converts to this type from the input type.
Source§

impl<'cglue_a, CGlueInst, CGlueCtx: ContextBounds> From<ControllerFeaturesWithClone<'cglue_a, CGlueInst, CGlueCtx>> for ControllerFeatures<'cglue_a, CGlueInst, CGlueCtx>
where ControllerFeaturesContainer<CGlueInst, CGlueCtx>: CGlueObjBase,

Source§

fn from( input: ControllerFeaturesWithClone<'cglue_a, CGlueInst, CGlueCtx>, ) -> Self

Converts to this type from the input type.
Source§

impl<'cglue_a, CGlueInst, CGlueCtx: ContextBounds> From<ControllerFeaturesWithCloneKeyboardWriter<'cglue_a, CGlueInst, CGlueCtx>> for ControllerFeatures<'cglue_a, CGlueInst, CGlueCtx>
where ControllerFeaturesContainer<CGlueInst, CGlueCtx>: CGlueObjBase,

Source§

fn from( input: ControllerFeaturesWithCloneKeyboardWriter<'cglue_a, CGlueInst, CGlueCtx>, ) -> Self

Converts to this type from the input type.
Source§

impl<'cglue_a, CGlueInst, CGlueCtx: ContextBounds> From<ControllerFeaturesWithCloneKeyboardWriterMouseWriter<'cglue_a, CGlueInst, CGlueCtx>> for ControllerFeatures<'cglue_a, CGlueInst, CGlueCtx>
where ControllerFeaturesContainer<CGlueInst, CGlueCtx>: CGlueObjBase,

Source§

fn from( input: ControllerFeaturesWithCloneKeyboardWriterMouseWriter<'cglue_a, CGlueInst, CGlueCtx>, ) -> Self

Converts to this type from the input type.
Source§

impl<'cglue_a, CGlueInst, CGlueCtx: ContextBounds> From<ControllerFeaturesWithCloneMouseWriter<'cglue_a, CGlueInst, CGlueCtx>> for ControllerFeatures<'cglue_a, CGlueInst, CGlueCtx>
where ControllerFeaturesContainer<CGlueInst, CGlueCtx>: CGlueObjBase,

Source§

fn from( input: ControllerFeaturesWithCloneMouseWriter<'cglue_a, CGlueInst, CGlueCtx>, ) -> Self

Converts to this type from the input type.
Source§

impl<'cglue_a, CGlueInst, CGlueCtx: ContextBounds> From<ControllerFeaturesWithKeyboardWriter<'cglue_a, CGlueInst, CGlueCtx>> for ControllerFeatures<'cglue_a, CGlueInst, CGlueCtx>
where ControllerFeaturesContainer<CGlueInst, CGlueCtx>: CGlueObjBase,

Source§

fn from( input: ControllerFeaturesWithKeyboardWriter<'cglue_a, CGlueInst, CGlueCtx>, ) -> Self

Converts to this type from the input type.
Source§

impl<'cglue_a, CGlueInst, CGlueCtx: ContextBounds> From<ControllerFeaturesWithKeyboardWriterMouseWriter<'cglue_a, CGlueInst, CGlueCtx>> for ControllerFeatures<'cglue_a, CGlueInst, CGlueCtx>
where ControllerFeaturesContainer<CGlueInst, CGlueCtx>: CGlueObjBase,

Source§

fn from( input: ControllerFeaturesWithKeyboardWriterMouseWriter<'cglue_a, CGlueInst, CGlueCtx>, ) -> Self

Converts to this type from the input type.
Source§

impl<'cglue_a, CGlueInst, CGlueCtx: ContextBounds> From<ControllerFeaturesWithMouseWriter<'cglue_a, CGlueInst, CGlueCtx>> for ControllerFeatures<'cglue_a, CGlueInst, CGlueCtx>
where ControllerFeaturesContainer<CGlueInst, CGlueCtx>: CGlueObjBase,

Source§

fn from( input: ControllerFeaturesWithMouseWriter<'cglue_a, CGlueInst, CGlueCtx>, ) -> Self

Converts to this type from the input type.
Source§

impl<CGlueInst: Deref, CGlueCtx: ContextBounds> GetContainer for ControllerFeatures<'_, CGlueInst, CGlueCtx>
where ControllerFeaturesContainer<CGlueInst, CGlueCtx>: CGlueObjBase,

Source§

type ContType = ControllerFeaturesContainer<CGlueInst, CGlueCtx>

Source§

fn ccont_ref(&self) -> &Self::ContType

Source§

fn ccont_mut(&mut self) -> &mut Self::ContType

Source§

fn into_ccont(self) -> Self::ContType

Source§

fn build_with_ccont(&self, container: Self::ContType) -> Self

Source§

impl<'cglue_a, CGlueInst, CGlueCtx> GetStaticEquivalent_ for ControllerFeatures<'cglue_a, CGlueInst, CGlueCtx>
where ControllerFeaturesContainer<CGlueInst, CGlueCtx>: CGlueObjBase, CGlueInst: __StableAbi + 'cglue_a, CGlueCtx: __StableAbi + ContextBounds,

Source§

type StaticEquivalent = _static_ControllerFeatures<'static, <CGlueInst as GetStaticEquivalent_>::StaticEquivalent, <CGlueCtx as GetStaticEquivalent_>::StaticEquivalent>

Source§

impl<'cglue_a, CGlueInst, CGlueCtx: ContextBounds> GetVtbl<LoadableVtbl<'cglue_a, ControllerFeaturesContainer<CGlueInst, CGlueCtx>>> for ControllerFeatures<'cglue_a, CGlueInst, CGlueCtx>
where ControllerFeaturesContainer<CGlueInst, CGlueCtx>: CGlueObjBase,

Source§

fn get_vtbl( &self, ) -> &LoadableVtbl<'cglue_a, ControllerFeaturesContainer<CGlueInst, CGlueCtx>>

Source§

impl<'cglue_a, CGlueInst: Opaquable, CGlueCtx: ContextBounds> Opaquable for ControllerFeatures<'cglue_a, CGlueInst, CGlueCtx>
where ControllerFeaturesContainer<CGlueInst, CGlueCtx>: CGlueObjBase, ControllerFeaturesContainer<CGlueInst::OpaqueTarget, CGlueCtx>: CGlueObjBase,

Convert into opaque object.

This is the prerequisite for using underlying trait implementations.

Source§

type OpaqueTarget = ControllerFeatures<'cglue_a, <CGlueInst as Opaquable>::OpaqueTarget, CGlueCtx>

Source§

fn into_opaque(self) -> Self::OpaqueTarget

Transform self into an opaque version of the trait object. Read more
Source§

impl<'cglue_a, CGlueInst, CGlueCtx> StableAbi for ControllerFeatures<'cglue_a, CGlueInst, CGlueCtx>
where ControllerFeaturesContainer<CGlueInst, CGlueCtx>: CGlueObjBase, CGlueInst: __StableAbi + 'cglue_a, CGlueCtx: __StableAbi + ContextBounds,

Source§

const LAYOUT: &'static TypeLayout

The layout of the type provided by implementors.
Source§

type IsNonZeroType = False

Whether this type has a single invalid bit-pattern. Read more
Source§

const ABI_CONSTS: AbiConsts = _

const-equivalents of the associated types.

Auto Trait Implementations§

§

impl<'cglue_a, CGlueInst, CGlueCtx> Freeze for ControllerFeatures<'cglue_a, CGlueInst, CGlueCtx>
where &'cglue_a LoadableVtbl<'cglue_a, ControllerFeaturesContainer<CGlueInst, CGlueCtx>>: Freeze, Option<&'cglue_a CloneVtbl<'cglue_a, ControllerFeaturesContainer<CGlueInst, CGlueCtx>>>: Freeze, Option<&'cglue_a KeyboardWriterVtbl<'cglue_a, ControllerFeaturesContainer<CGlueInst, CGlueCtx>>>: Freeze, Option<&'cglue_a MouseWriterVtbl<'cglue_a, ControllerFeaturesContainer<CGlueInst, CGlueCtx>>>: Freeze, ControllerFeaturesContainer<CGlueInst, CGlueCtx>: Freeze,

§

impl<'cglue_a, CGlueInst, CGlueCtx> RefUnwindSafe for ControllerFeatures<'cglue_a, CGlueInst, CGlueCtx>
where &'cglue_a LoadableVtbl<'cglue_a, ControllerFeaturesContainer<CGlueInst, CGlueCtx>>: RefUnwindSafe, Option<&'cglue_a CloneVtbl<'cglue_a, ControllerFeaturesContainer<CGlueInst, CGlueCtx>>>: RefUnwindSafe, Option<&'cglue_a KeyboardWriterVtbl<'cglue_a, ControllerFeaturesContainer<CGlueInst, CGlueCtx>>>: RefUnwindSafe, Option<&'cglue_a MouseWriterVtbl<'cglue_a, ControllerFeaturesContainer<CGlueInst, CGlueCtx>>>: RefUnwindSafe, ControllerFeaturesContainer<CGlueInst, CGlueCtx>: RefUnwindSafe,

§

impl<'cglue_a, CGlueInst, CGlueCtx> Send for ControllerFeatures<'cglue_a, CGlueInst, CGlueCtx>
where &'cglue_a LoadableVtbl<'cglue_a, ControllerFeaturesContainer<CGlueInst, CGlueCtx>>: Send, Option<&'cglue_a CloneVtbl<'cglue_a, ControllerFeaturesContainer<CGlueInst, CGlueCtx>>>: Send, Option<&'cglue_a KeyboardWriterVtbl<'cglue_a, ControllerFeaturesContainer<CGlueInst, CGlueCtx>>>: Send, Option<&'cglue_a MouseWriterVtbl<'cglue_a, ControllerFeaturesContainer<CGlueInst, CGlueCtx>>>: Send, ControllerFeaturesContainer<CGlueInst, CGlueCtx>: Send,

§

impl<'cglue_a, CGlueInst, CGlueCtx> Sync for ControllerFeatures<'cglue_a, CGlueInst, CGlueCtx>
where &'cglue_a LoadableVtbl<'cglue_a, ControllerFeaturesContainer<CGlueInst, CGlueCtx>>: Sync, Option<&'cglue_a CloneVtbl<'cglue_a, ControllerFeaturesContainer<CGlueInst, CGlueCtx>>>: Sync, Option<&'cglue_a KeyboardWriterVtbl<'cglue_a, ControllerFeaturesContainer<CGlueInst, CGlueCtx>>>: Sync, Option<&'cglue_a MouseWriterVtbl<'cglue_a, ControllerFeaturesContainer<CGlueInst, CGlueCtx>>>: Sync, ControllerFeaturesContainer<CGlueInst, CGlueCtx>: Sync,

§

impl<'cglue_a, CGlueInst, CGlueCtx> Unpin for ControllerFeatures<'cglue_a, CGlueInst, CGlueCtx>
where &'cglue_a LoadableVtbl<'cglue_a, ControllerFeaturesContainer<CGlueInst, CGlueCtx>>: Unpin, Option<&'cglue_a CloneVtbl<'cglue_a, ControllerFeaturesContainer<CGlueInst, CGlueCtx>>>: Unpin, Option<&'cglue_a KeyboardWriterVtbl<'cglue_a, ControllerFeaturesContainer<CGlueInst, CGlueCtx>>>: Unpin, Option<&'cglue_a MouseWriterVtbl<'cglue_a, ControllerFeaturesContainer<CGlueInst, CGlueCtx>>>: Unpin, ControllerFeaturesContainer<CGlueInst, CGlueCtx>: Unpin,

§

impl<'cglue_a, CGlueInst, CGlueCtx> UnsafeUnpin for ControllerFeatures<'cglue_a, CGlueInst, CGlueCtx>
where &'cglue_a LoadableVtbl<'cglue_a, ControllerFeaturesContainer<CGlueInst, CGlueCtx>>: UnsafeUnpin, Option<&'cglue_a CloneVtbl<'cglue_a, ControllerFeaturesContainer<CGlueInst, CGlueCtx>>>: UnsafeUnpin, Option<&'cglue_a KeyboardWriterVtbl<'cglue_a, ControllerFeaturesContainer<CGlueInst, CGlueCtx>>>: UnsafeUnpin, Option<&'cglue_a MouseWriterVtbl<'cglue_a, ControllerFeaturesContainer<CGlueInst, CGlueCtx>>>: UnsafeUnpin, ControllerFeaturesContainer<CGlueInst, CGlueCtx>: UnsafeUnpin,

§

impl<'cglue_a, CGlueInst, CGlueCtx> UnwindSafe for ControllerFeatures<'cglue_a, CGlueInst, CGlueCtx>
where &'cglue_a LoadableVtbl<'cglue_a, ControllerFeaturesContainer<CGlueInst, CGlueCtx>>: UnwindSafe, Option<&'cglue_a CloneVtbl<'cglue_a, ControllerFeaturesContainer<CGlueInst, CGlueCtx>>>: UnwindSafe, Option<&'cglue_a KeyboardWriterVtbl<'cglue_a, ControllerFeaturesContainer<CGlueInst, CGlueCtx>>>: UnwindSafe, Option<&'cglue_a MouseWriterVtbl<'cglue_a, ControllerFeaturesContainer<CGlueInst, CGlueCtx>>>: UnwindSafe, ControllerFeaturesContainer<CGlueInst, CGlueCtx>: UnwindSafe,

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T, F> From2<T> for F
where T: Into<F>,

Source§

fn from2(other: T) -> F

Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T> GenericTypeBounds for T
where T: StableAbi,

Source§

impl<T> GetWithMetadata for T

Source§

type ForSelf = WithMetadata_<T, T>

This is always WithMetadata_<Self, Self>
Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<'cglue_a, CGlueO> Loadable for CGlueO
where CGlueO: 'cglue_a + GetContainer + GetVtbl<LoadableVtbl<'cglue_a, <CGlueO as GetContainer>::ContType>> + LoadableOpaqueObj<'cglue_a>, LoadableVtbl<'cglue_a, <CGlueO as GetContainer>::ContType>: StableAbi,

Source§

fn name(&self) -> RString

Source§

fn capabilities(&self) -> u8

U8 bitflags of capabilities. Sadly I have not yet figured out how to get the bitflags crate to play nice with abi_stable so this is base type for now
Source§

impl<'cglue_a, CGlueO> LoadableOpaqueObj<'cglue_a> for CGlueO
where CGlueO: 'cglue_a + GetContainer + GetVtbl<LoadableVtbl<'cglue_a, <CGlueO as GetContainer>::ContType>>, <CGlueO as GetContainer>::ContType: StableAbi,

Source§

type LoadableVtbl = LoadableVtbl<'cglue_a, <CGlueO as GetContainer>::ContType>

Source§

impl<T> Opaque for T
where T: Opaquable<OpaqueTarget = T>,

Source§

impl<S> ROExtAcc for S

Source§

fn f_get<F>(&self, offset: FieldOffset<S, F, Aligned>) -> &F

Gets a reference to a field, determined by offset. Read more
Source§

fn f_get_mut<F>(&mut self, offset: FieldOffset<S, F, Aligned>) -> &mut F

Gets a muatble reference to a field, determined by offset. Read more
Source§

fn f_get_ptr<F, A>(&self, offset: FieldOffset<S, F, A>) -> *const F

Gets a const pointer to a field, the field is determined by offset. Read more
Source§

fn f_get_mut_ptr<F, A>(&mut self, offset: FieldOffset<S, F, A>) -> *mut F

Gets a mutable pointer to a field, determined by offset. Read more
Source§

impl<S> ROExtOps<Aligned> for S

Source§

fn f_replace<F>(&mut self, offset: FieldOffset<S, F, Aligned>, value: F) -> F

Replaces a field (determined by offset) with value, returning the previous value of the field. Read more
Source§

fn f_swap<F>(&mut self, offset: FieldOffset<S, F, Aligned>, right: &mut S)

Swaps a field (determined by offset) with the same field in right. Read more
Source§

fn f_get_copy<F>(&self, offset: FieldOffset<S, F, Aligned>) -> F
where F: Copy,

Gets a copy of a field (determined by offset). The field is determined by offset. Read more
Source§

impl<S> ROExtOps<Unaligned> for S

Source§

fn f_replace<F>(&mut self, offset: FieldOffset<S, F, Unaligned>, value: F) -> F

Replaces a field (determined by offset) with value, returning the previous value of the field. Read more
Source§

fn f_swap<F>(&mut self, offset: FieldOffset<S, F, Unaligned>, right: &mut S)

Swaps a field (determined by offset) with the same field in right. Read more
Source§

fn f_get_copy<F>(&self, offset: FieldOffset<S, F, Unaligned>) -> F
where F: Copy,

Gets a copy of a field (determined by offset). The field is determined by offset. Read more
Source§

impl<T> SelfOps for T
where T: ?Sized,

Source§

fn eq_id(&self, other: &Self) -> bool

Compares the address of self with the address of other. Read more
Source§

fn piped<F, U>(self, f: F) -> U
where F: FnOnce(Self) -> U, Self: Sized,

Emulates the pipeline operator, allowing method syntax in more places. Read more
Source§

fn piped_ref<'a, F, U>(&'a self, f: F) -> U
where F: FnOnce(&'a Self) -> U,

The same as piped except that the function takes &Self Useful for functions that take &Self instead of Self. Read more
Source§

fn piped_mut<'a, F, U>(&'a mut self, f: F) -> U
where F: FnOnce(&'a mut Self) -> U,

The same as piped, except that the function takes &mut Self. Useful for functions that take &mut Self instead of Self.
Source§

fn mutated<F>(self, f: F) -> Self
where F: FnOnce(&mut Self), Self: Sized,

Mutates self using a closure taking self by mutable reference, passing it along the method chain. Read more
Source§

fn observe<F>(self, f: F) -> Self
where F: FnOnce(&Self), Self: Sized,

Observes the value of self, passing it along unmodified. Useful in long method chains. Read more
Source§

fn into_<T>(self) -> T
where Self: Into<T>,

Performs a conversion with Into. using the turbofish .into_::<_>() syntax. Read more
Source§

fn as_ref_<T>(&self) -> &T
where Self: AsRef<T>, T: ?Sized,

Performs a reference to reference conversion with AsRef, using the turbofish .as_ref_::<_>() syntax. Read more
Source§

fn as_mut_<T>(&mut self) -> &mut T
where Self: AsMut<T>, T: ?Sized,

Performs a mutable reference to mutable reference conversion with AsMut, using the turbofish .as_mut_::<_>() syntax. Read more
Source§

fn drop_(self)
where Self: Sized,

Drops self using method notation. Alternative to std::mem::drop. Read more
Source§

impl<This> TransmuteElement for This
where This: ?Sized,

Source§

unsafe fn transmute_element<T>(self) -> Self::TransmutedPtr
where Self: CanTransmuteElement<T>,

Transmutes the element type of this pointer.. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = !

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, !>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
Source§

impl<T> TypeIdentity for T
where T: ?Sized,

Source§

type Type = T

This is always Self.
Source§

fn into_type(self) -> Self::Type
where Self: Sized, Self::Type: Sized,

Converts a value back to the original type.
Source§

fn as_type(&self) -> &Self::Type

Converts a reference back to the original type.
Source§

fn as_type_mut(&mut self) -> &mut Self::Type

Converts a mutable reference back to the original type.
Source§

fn into_type_box(self: Box<Self>) -> Box<Self::Type>

Converts a box back to the original type.
Source§

fn into_type_arc(this: Arc<Self>) -> Arc<Self::Type> ⓘ

Converts an Arc back to the original type. Read more
Source§

fn into_type_rc(this: Rc<Self>) -> Rc<Self::Type>

Converts an Rc back to the original type. Read more
Source§

fn from_type(this: Self::Type) -> Self
where Self: Sized, Self::Type: Sized,

Converts a value back to the original type.
Source§

fn from_type_ref(this: &Self::Type) -> &Self

Converts a reference back to the original type.
Source§

fn from_type_mut(this: &mut Self::Type) -> &mut Self

Converts a mutable reference back to the original type.
Source§

fn from_type_box(this: Box<Self::Type>) -> Box<Self>

Converts a box back to the original type.
Source§

fn from_type_arc(this: Arc<Self::Type>) -> Arc<Self> ⓘ

Converts an Arc back to the original type.
Source§

fn from_type_rc(this: Rc<Self::Type>) -> Rc<Self>

Converts an Rc back to the original type.