Struct SinglePluginEntry 

pub struct SinglePluginEntry<P: DefaultPluginFactory> { /* private fields */ }

An Entry that only exposes a single plugin type to the host.

This is a simplified entry type, which only requires the simple DefaultPluginFactory trait to be implemented by the user, and implements an entry and plugin factory around it.

This entry type exists purely for convenience of the users in the common case of having a single plugin type to expose to the host.

If you actually need to expose more plugin types, or to customize the entry’s behavior in some other way, see the Entry trait documentation for an example on how to implement your own custom entry.

Example

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

pub struct MyPlugin;

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

impl DefaultPluginFactory for MyPlugin {
    fn get_descriptor() -> PluginDescriptor {
        PluginDescriptor::new("my.plugin", "My Plugin")
    }

    fn new_shared<'a>(
        _host: HostSharedHandle<'a>
    ) -> Result<Self::Shared<'a>, PluginError> {
        Ok(())
    }

    fn new_main_thread<'a>(
        host: HostMainThreadHandle<'a>,
        shared: &'a Self::Shared<'a>
    ) -> Result<Self::MainThread<'a>, PluginError> {
        Ok(())
    }
}

clack_export_entry!(SinglePluginEntry::<MyPlugin>);

Trait Implementations

impl<P: DefaultPluginFactory> Entry for SinglePluginEntry<P>

fn new(_plugin_path: Option<&CStr>) -> Result<Self, EntryLoadError>

Instantiates the entry.

fn declare_factories<'a>(&'a self, builder: &mut EntryFactories<'a>)

Declares the factories this entry exposes to the host, by registering them to the given EntryFactories builder.