alex/nih-plug
1
0
Fork 0
Code Activity

Get rid of qualified imports in nih_export_clap!()

Browse source 
Adding these in the outer block would pollute the namespace but we can
do whatever we want in the inner module.
This commit is contained in:
Robbert van der Helm 2023-09-03 14:00:03 +02:00
parent c5bfb33d24
commit b9b30feb86
1 changed files with 36 additions and 38 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

66
src/wrapper/clap.rs
View file

@ -25,12 +25,20 @@ macro_rules! nih_export_clap {
// macros. So instead we'll generate the implementation ad-hoc inside of this macro. // macros. So instead we'll generate the implementation ad-hoc inside of this macro.
#[doc(hidden)] #[doc(hidden)]
mod clap { mod clap {
use $crate::prelude::nih_debug_assert_eq;
use $crate::wrapper::setup_logger;
use $crate::wrapper::clap::{PluginDescriptor, Wrapper};
use $crate::wrapper::clap::{CLAP_PLUGIN_FACTORY_ID, clap_host, clap_plugin, clap_plugin_descriptor, clap_plugin_factory};
use ::std::collections::HashSet;
use ::std::ffi::{CStr, c_void};
use ::std::os::raw::c_char;
use ::std::sync::{Arc, OnceLock};
// Because the `$plugin_ty`s are likely defined in the enclosing scope. This works even // Because the `$plugin_ty`s are likely defined in the enclosing scope. This works even
// if the types are not public because this is a child module. // if the types are not public because this is a child module.
use super::*; use super::*;
const CLAP_PLUGIN_FACTORY: $crate::wrapper::clap::clap_plugin_factory = const CLAP_PLUGIN_FACTORY: clap_plugin_factory = clap_plugin_factory {
$crate::wrapper::clap::clap_plugin_factory {
get_plugin_count: Some(get_plugin_count), get_plugin_count: Some(get_plugin_count),
get_plugin_descriptor: Some(get_plugin_descriptor), get_plugin_descriptor: Some(get_plugin_descriptor),
create_plugin: Some(create_plugin), create_plugin: Some(create_plugin),
@ -42,18 +50,15 @@ macro_rules! nih_export_clap {
// We'll put these plugin descriptors in a tuple since we can't easily associate them // We'll put these plugin descriptors in a tuple since we can't easily associate them
// with indices without involving even more macros. We can't initialize this tuple // with indices without involving even more macros. We can't initialize this tuple
// completely statically // completely statically
static PLUGIN_DESCRIPTORS: ::std::sync::OnceLock< static PLUGIN_DESCRIPTORS: OnceLock<[PluginDescriptor; PLUGIN_COUNT]> = OnceLock::new();
[$crate::wrapper::clap::PluginDescriptor; PLUGIN_COUNT]
> = ::std::sync::OnceLock::new();
fn plugin_descriptors() -> &'static [$crate::wrapper::clap::PluginDescriptor; PLUGIN_COUNT] { fn plugin_descriptors() -> &'static [PluginDescriptor; PLUGIN_COUNT] {
PLUGIN_DESCRIPTORS.get_or_init(|| { PLUGIN_DESCRIPTORS.get_or_init(|| {
let descriptors = [$($crate::wrapper::clap::PluginDescriptor::for_plugin::<$plugin_ty>()),+]; let descriptors = [$(PluginDescriptor::for_plugin::<$plugin_ty>()),+];
if cfg!(debug_assertions) { if cfg!(debug_assertions) {
let unique_plugin_ids: std::collections::HashSet<_> let unique_plugin_ids: HashSet<_> = descriptors.iter().map(|d| d.clap_id()).collect();
= descriptors.iter().map(|d| d.clap_id()).collect(); nih_debug_assert_eq!(
$crate::debug::nih_debug_assert_eq!(
unique_plugin_ids.len(), unique_plugin_ids.len(),
descriptors.len(), descriptors.len(),
"Duplicate plugin IDs found in `nih_export_clap!()` call" "Duplicate plugin IDs found in `nih_export_clap!()` call"
@ -64,31 +69,29 @@ macro_rules! nih_export_clap {
}) })
} }
unsafe extern "C" fn get_plugin_count( unsafe extern "C" fn get_plugin_count(_factory: *const clap_plugin_factory) -> u32 {
_factory: *const $crate::wrapper::clap::clap_plugin_factory,
) -> u32 {
plugin_descriptors().len() as u32 plugin_descriptors().len() as u32
} }
unsafe extern "C" fn get_plugin_descriptor ( unsafe extern "C" fn get_plugin_descriptor (
_factory: *const $crate::wrapper::clap::clap_plugin_factory, _factory: *const clap_plugin_factory,
index: u32, index: u32,
) -> *const $crate::wrapper::clap::clap_plugin_descriptor { ) -> *const clap_plugin_descriptor {
match plugin_descriptors().get(index as usize) { match plugin_descriptors().get(index as usize) {
Some(descriptor) => descriptor.clap_plugin_descriptor(), Some(descriptor) => descriptor.clap_plugin_descriptor(),
None => std::ptr::null() None => ::std::ptr::null()
} }
} }
unsafe extern "C" fn create_plugin ( unsafe extern "C" fn create_plugin (
factory: *const $crate::wrapper::clap::clap_plugin_factory, factory: *const clap_plugin_factory,
host: *const $crate::wrapper::clap::clap_host, host: *const clap_host,
plugin_id: *const ::std::os::raw::c_char, plugin_id: *const c_char,
) -> *const $crate::wrapper::clap::clap_plugin { ) -> *const clap_plugin {
if plugin_id.is_null() { if plugin_id.is_null() {
return ::std::ptr::null(); return ::std::ptr::null();
} }
let plugin_id_cstr = ::std::ffi::CStr::from_ptr(plugin_id); let plugin_id_cstr = CStr::from_ptr(plugin_id);
// This isn't great, but we'll just assume that `$plugin_ids` and the descriptors // This isn't great, but we'll just assume that `$plugin_ids` and the descriptors
// are in the same order. We also can't directly enumerate over them with an index, // are in the same order. We also can't directly enumerate over them with an index,
@ -102,7 +105,7 @@ macro_rules! nih_export_clap {
// Arc does not have a convenient leak function like Box, so this gets a bit awkward // Arc does not have a convenient leak function like Box, so this gets a bit awkward
// This pointer gets turned into an Arc and its reference count decremented in // This pointer gets turned into an Arc and its reference count decremented in
// [Wrapper::destroy()] // [Wrapper::destroy()]
return (*::std::sync::Arc::into_raw($crate::wrapper::clap::Wrapper::<$plugin_ty>::new(host))) return (*Arc::into_raw(Wrapper::<$plugin_ty>::new(host)))
.clap_plugin .clap_plugin
.as_ptr(); .as_ptr();
} }
@ -110,26 +113,21 @@ macro_rules! nih_export_clap {
descriptor_idx += 1; descriptor_idx += 1;
})+ })+
std::ptr::null() ::std::ptr::null()
} }
pub extern "C" fn init(_plugin_path: *const ::std::os::raw::c_char) -> bool { pub extern "C" fn init(_plugin_path: *const c_char) -> bool {
$crate::wrapper::setup_logger(); setup_logger();
true true
} }
pub extern "C" fn deinit() {} pub extern "C" fn deinit() {}
pub extern "C" fn get_factory( pub extern "C" fn get_factory(factory_id: *const c_char) -> *const c_void {
factory_id: *const ::std::os::raw::c_char, if !factory_id.is_null() && unsafe { CStr::from_ptr(factory_id) } == CLAP_PLUGIN_FACTORY_ID {
) -> *const ::std::ffi::c_void { &CLAP_PLUGIN_FACTORY as *const _ as *const c_void
if !factory_id.is_null()
&& unsafe { ::std::ffi::CStr::from_ptr(factory_id) }
== $crate::wrapper::clap::CLAP_PLUGIN_FACTORY_ID
{
&CLAP_PLUGIN_FACTORY as *const _ as *const ::std::ffi::c_void
} else { } else {
std::ptr::null() ::std::ptr::null()
} }
} }
} }