Struct PluginInstance

Source

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

Expand description

A wrapper around a Plugin instance.

This type is created with its new method when the host wants to instantiate a given plugin type, and is what needs to be returned by the PluginFactory::instantiate_plugin method.

Implementations§

Source §

impl<'a> PluginInstance<'a>

Source

pub fn new<P: Plugin>( host_info: HostInfo<'a>, descriptor: &'a PluginDescriptor, shared_initializer: impl FnOnce(HostSharedHandle<'a>) -> Result<P::Shared<'a>, PluginError> + 'a, main_thread_initializer: impl FnOnce(HostMainThreadHandle<'a>, &'a P::Shared<'a>) -> Result<P::MainThread<'a>, PluginError> + 'a, ) -> PluginInstance<'a>

Instantiates a plugin of a given implementation P.

Instantiated plugins also require an HostInfo instance given by the host, and a reference to the associated PluginDescriptor.

See the PluginFactory’s trait documentation for a usage example.

Source

pub fn new_with_initializer<P: Plugin, FM>( host_info: HostInfo<'a>, descriptor: &'a PluginDescriptor, initializer: impl FnOnce(HostMainThreadHandle<'a>) -> Result<(P::Shared<'a>, FM), PluginError> + 'a, ) -> PluginInstance<'a>
where FM: 'a + FnOnce(&'a P::Shared<'a>) -> Result<P::MainThread<'a>, PluginError>,

Instantiates a plugin of a given implementation P with a custom initializer.

This initializer allows to perform custom work on the main thread at initialization time before the plugin is split into its shared and main thread components.

Instantiated plugins also require an HostInfo instance given by the host, and a reference to the associated PluginDescriptor.

§Example

This example shows how to use this API to create a PluginShared struct and a PluginMainThread struct that each use one end of a channel.

use std::sync::mpsc::{channel, Receiver, Sender};

use clack_plugin::prelude::*;
use clack_plugin::entry::prelude::*;

struct MyPlugin;

impl Plugin for MyPlugin {
    type AudioProcessor<'a> = ();
    type Shared<'a> = MyPluginShared<'a>;
    type MainThread<'a> = MyPluginMainThread<'a>;
}

struct MyPluginShared<'a>(HostSharedHandle<'a>, Sender<u32>);
struct MyPluginMainThread<'a>(HostMainThreadHandle<'a>, &'a MyPluginShared<'a>, Receiver<u32>);

impl<'a> PluginShared<'a> for MyPluginShared<'a> {}
impl<'a> PluginMainThread<'a, MyPluginShared<'a>> for MyPluginMainThread<'a> {}

fn create_plugin<'a>(host_info: HostInfo<'a>) -> Result<PluginInstance<'a>, PluginError> {
    let plugin_descriptor: &'a PluginDescriptor = /* ... */
    Ok(PluginInstance::new_with_initializer::<MyPlugin, _>(host_info, plugin_descriptor, |host| {
        let (tx, rx) = channel();

        Ok((
            MyPluginShared(host.shared(), tx),
            move |shared| Ok(MyPluginMainThread(host, shared, rx))
        ))
    }))
}