Struct RawExtension 

pub struct RawExtension<S, T = ()>
where
    S: ExtensionSide,
{ /* private fields */ }

A raw extension pointer.

This type is used by extension implementations to abstract away most of the safety concerns of using extension pointers.

Using the S type parameter with either PluginExtensionSide or HostExtensionSide, this can be used as either a plugin-side extension or a host-side extension, respectively.

The T type parameter is the extension struct this points to (e.g. clap_plugin_state), or () if the extension pointer is untyped.

Internally, this holds two pointers: a pointer to the actual extension struct, and a pointer to the matching clap_plugin or clap_host. These are compared on each use to make sure that the right extensions are always called with the right instance.

This type does not directly track the lifetimes of its pointers at all, they may become dangling at any time. However, it is part of the safety contract of this type that the extension pointer MUST be valid as long as the matching clap_plugin or clap_host still is, as per the CLAP specification.

This property is then extrapolated so that if any valid clap_plugin or clap_host reference, that also matches the pointer stored in this type, is encountered, then it must mean that the inner extension pointer is also valid, and can be safely de-referenced.

To safely get valid references to the extension struct out of this type, you have to use the use_extension() method on one of the handle types:

• For plugin-side extensions (from the clack-host crate): PluginSharedHandle, PluginMainThreadHandle, or PluginAudioProcessorHandle;
• For host-side extensions (from the clack-plugin crate): HostSharedHandle, HostMainThreadHandle, or HostAudioProcessorHandle.

This pointer type is only useful for consuming extension pointers. For producing extension pointers from an extension implementation, use the RawExtensionImplementation type instead.

Implementations

impl<S, T> RawExtension<S, T>

where S: ExtensionSide,

pub const fn as_ptr(&self) -> NonNull<T>

Returns the raw pointer to the extension struct.

This pointer may be dangling at any time.

See the RawExtension type documentation for more information on how to get a valid reference to the extension struct instead.

impl<S> RawExtension<S>

where S: ExtensionSide,

pub const unsafe fn cast<T>(&self) -> RawExtension<S, T>

Casts this raw extension pointer into an extension pointer of a given type.

Safety

Users must ensure that T matches the actual type behind the pointer.

impl<T> RawExtension<PluginExtensionSide, T>

pub const unsafe fn from_raw_plugin_extension( extension_ptr: NonNull<T>, plugin_ptr: NonNull<clap_plugin>, ) -> RawExtension<PluginExtensionSide, T>

Creates a raw plugin-side extension pointer from a pointer to the extension data, and a pointer to the plugin instance.

Safety

The user must ensure the extension_ptr is and remains valid for the lifetime of the plugin instance. This is the case for pointers received from the raw clap_plugin.get_extension method.

The given plugin_ptr however doesn’t have to be valid, and may be dangling.

pub const fn plugin_ptr(&self) -> NonNull<clap_plugin>

Returns the raw pointer to the plugin instance the extension originated from.

This pointer may be dangling at any time, and is not meant to be de-referenced, only compared to. See the RawExtension type documentation for more information.

impl<T> RawExtension<HostExtensionSide, T>

pub const unsafe fn from_raw_host_extension( extension_ptr: NonNull<T>, host_ptr: NonNull<clap_host>, ) -> RawExtension<HostExtensionSide, T>

Creates a raw host-side extension pointer from a pointer to the extension data, and a pointer to the plugin instance.

Safety

The user must ensure the extension_ptr is and remains valid for the lifetime of the plugin instance. This is the case for pointers received from the raw clap_host.get_extension method.

The given host_ptr however doesn’t have to be valid, and may be dangling.

pub const fn host_ptr(&self) -> NonNull<clap_host>

Returns the raw pointer to the host instance the extension originated from.

This pointer may be dangling at any time, and is not meant to be de-referenced, only compared to. See the RawExtension type documentation for more information.

Trait Implementations

impl<S, T> Clone for RawExtension<S, T>

where S: Clone + ExtensionSide, T: Clone,

fn clone(&self) -> RawExtension<S, T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<S, T> Copy for RawExtension<S, T>

where S: Copy + ExtensionSide, T: Copy,

impl<S, T> Eq for RawExtension<S, T>

where S: Eq + ExtensionSide, T: Eq,

impl<S, T> Hash for RawExtension<S, T>

where S: Hash + ExtensionSide, T: Hash,

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<S, T> Ord for RawExtension<S, T>

where S: Ord + ExtensionSide, T: Ord,

fn cmp(&self, other: &RawExtension<S, T>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl<S, T> PartialEq for RawExtension<S, T>

where S: PartialEq + ExtensionSide, T: PartialEq,

fn eq(&self, other: &RawExtension<S, T>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<S, T> PartialOrd for RawExtension<S, T>

where S: PartialOrd + ExtensionSide, T: PartialOrd,

fn partial_cmp(&self, other: &RawExtension<S, T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<S, T> Send for RawExtension<S, T>

where S: ExtensionSide,

impl<S, T> StructuralPartialEq for RawExtension<S, T>

where S: PartialEq + ExtensionSide, T: PartialEq,

impl<S, T> Sync for RawExtension<S, T>

where S: ExtensionSide,