Struct PluginMainThreadHandle 

pub struct PluginMainThreadHandle<'a> { /* private fields */ }

A main-thread handle to the plugin instance.

This can be used to make requests to the plugin that can only be made in the main thread, which is required for e.g. some extensions.

Implementations

impl<'a> PluginMainThreadHandle<'a>

pub const fn as_raw(&self) -> &'a clap_plugin

Returns a shared reference to the raw, C-FFI compatible plugin instance struct.

This type enforces that the reference is valid for the lifetime of the instance ('a).

If you need to access the raw pointer without dereferencing it first, use as_raw_ptr instead.

pub const fn as_raw_ptr(&self) -> *const clap_plugin

Returns a raw pointer to the raw, C-FFI compatible plugin instance struct, without dereferencing it.

If you need to safely access the plugin instance struct through a shared reference, use as_raw instead.

pub const fn shared(&self) -> PluginSharedHandle<'a>

Produces a PluginSharedHandle from this main-thread handle.

pub const fn as_shared(&self) -> &PluginSharedHandle<'a>

Turns this handle reference to a PluginSharedHandle reference.

Methods from Deref<Target = PluginSharedHandle<'a>>

pub fn descriptor(&self) -> Option<&'a PluginDescriptor>

Returns the PluginDescriptor this instance corresponds to.

This may return None if the underlying plugin implementation didn’t properly populate the descriptor pointer.

pub fn as_raw(&self) -> &'a clap_plugin

Returns a shared reference to the raw, C-FFI compatible plugin instance struct.

This type enforces that the reference is valid for the lifetime of the instance ('a).

If you need to access the raw pointer without dereferencing it first, use as_raw_ptr instead.

pub fn as_raw_ptr(&self) -> *const clap_plugin

Returns a raw pointer to the raw, C-FFI compatible plugin instance struct, without dereferencing it.

If you need to safely access the plugin instance struct through a shared reference, use as_raw instead.

pub fn get_extension<E: Extension<ExtensionSide = PluginExtensionSide>>( &self, ) -> Option<E>

Retrieves the plugin’s pointer to the given extension type E.

This returns None if the plugin does not support the given extension.

Example

use clack_extensions::params::{PluginParams};
use clack_host::plugin::PluginSharedHandle;

let info: PluginSharedHandle = /* ... */
if let Some(params) = info.get_extension::<PluginParams>() {
    // The params extension is supported by this plugin
} else {
    // The params extension is not supported by this plugin
}

pub fn use_extension<E: Sized>( &self, extension: &RawExtension<PluginExtensionSide, E>, ) -> &'a E

Safely dereferences a RawExtension pointer produced by this plugin instance.

See the documentation of the RawExtension type for more information about how this works internally.

Panics

This method will panic if the given extension pointer does not match the plugin instance of this handle.

Trait Implementations

impl Debug for PluginMainThreadHandle<'_>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> Deref for PluginMainThreadHandle<'a>

type Target = PluginSharedHandle<'a>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'a> Eq for PluginMainThreadHandle<'a>

impl<'a> PartialEq for PluginMainThreadHandle<'a>

fn eq(&self, other: &PluginMainThreadHandle<'a>) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<'a> StructuralPartialEq for PluginMainThreadHandle<'a>