Struct emf_core_base_rs::CBaseRef

pub struct CBaseRef<'interface> { /* fields omitted */ }

Borrowed emf-core-base interface.

Implementations

impl CBaseRef<'_>

pub unsafe fn new(interface: NonNullConst<CBaseInterface>) -> Self

Constructs itself using the native interface.

Safety

This function is unsafe, as it enables bypassing the locking mechanism.

Trait Implementations

impl<'interface> CBaseInterfaceInfo for CBaseRef<'interface>

type Interface = CBaseInterface

Type of the interface.

fn interface_version(&self) -> Version

Returns the version of the interface.

fn internal_interface(&self) -> &Self::Interface

Fetches the internal low-level interface.

impl<'interface> Debug for CBaseRef<'interface>

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

Formats the value using the given formatter.

impl LibraryBinding for CBaseRef<'_>

unsafe fn register_loader(
    &mut self,
    loader: NonNullConst<LibraryLoaderInterface>,
    lib_type: NonNullConst<LibraryType>
) -> Result<LoaderHandle, Error>

Registers a new loader.

unsafe fn unregister_loader(
    &mut self,
    handle: LoaderHandle
) -> Result<i8, Error>

Unregisters an existing loader.

unsafe fn get_loader_interface(
    &mut self,
    handle: LoaderHandle
) -> Result<NonNullConst<LibraryLoaderInterface>, Error>

Fetches the interface of a library loader.

unsafe fn get_loader_handle_from_type(
    &self,
    lib_type: NonNullConst<LibraryType>
) -> Result<LoaderHandle, Error>

Fetches the loader handle associated with the library type.

unsafe fn get_loader_handle_from_library(
    &self,
    handle: LibraryHandle
) -> Result<LoaderHandle, Error>

Fetches the loader handle linked with the library handle.

unsafe fn get_num_loaders(&self) -> usize

Fetches the number of registered loaders.

unsafe fn library_exists(&self, handle: LibraryHandle) -> Bool

Checks if a the library handle is valid.

unsafe fn type_exists(&self, lib_type: NonNullConst<LibraryType>) -> Bool

Checks if a library type exists.

unsafe fn get_library_types(
    &self,
    buffer: NonNull<MutSpan<LibraryType>>
) -> Result<usize, Error>

Copies the strings of the registered library types into a buffer.

unsafe fn create_library_handle(&mut self) -> LibraryHandle

Creates a new unlinked library handle.

unsafe fn remove_library_handle(
    &mut self,
    handle: LibraryHandle
) -> Result<i8, Error>

Removes an existing library handle.

unsafe fn link_library(
    &mut self,
    handle: LibraryHandle,
    loader: LoaderHandle,
    internal: InternalHandle
) -> Result<i8, Error>

Links a library handle to an internal library handle.

unsafe fn get_internal_library_handle(
    &self,
    handle: LibraryHandle
) -> Result<InternalHandle, Error>

Fetches the internal handle linked with the library handle.

unsafe fn load(
    &mut self,
    loader: LoaderHandle,
    path: NonNullConst<OSPathChar>
) -> Result<LibraryHandle, Error>

Loads a library. The resulting handle is unique.

unsafe fn unload(&mut self, handle: LibraryHandle) -> Result<i8, Error>

Unloads a library.

unsafe fn get_data_symbol(
    &self,
    handle: LibraryHandle,
    symbol: NonNullConst<u8>
) -> Result<Symbol<NonNullConst<c_void>>, Error>

Fetches a data symbol from a library.

unsafe fn get_function_symbol(
    &self,
    handle: LibraryHandle,
    symbol: NonNullConst<u8>
) -> Result<Symbol<fn()>, Error>

Fetches a function symbol from a library.

impl ModuleBinding for CBaseRef<'_>

unsafe fn register_loader(
    &mut self,
    loader: NonNullConst<ModuleLoaderInterface>,
    mod_type: NonNullConst<ModuleType>
) -> Result<LoaderHandle, Error>

Registers a new module loader.

unsafe fn unregister_loader(
    &mut self,
    loader: LoaderHandle
) -> Result<i8, Error>

Unregisters an existing module loader.

unsafe fn get_loader_interface(
    &mut self,
    loader: LoaderHandle
) -> Result<NonNullConst<ModuleLoaderInterface>, Error>

Fetches the interface of a module loader.

unsafe fn get_loader_handle_from_type(
    &self,
    mod_type: NonNullConst<ModuleType>
) -> Result<LoaderHandle, Error>

Fetches the handle of the loader associated with a module type.

unsafe fn get_loader_handle_from_module(
    &self,
    handle: ModuleHandle
) -> Result<LoaderHandle, Error>

Fetches the handle of the loader linked with the module handle.

unsafe fn get_num_modules(&self) -> usize

Fetches the number of loaded modules.

unsafe fn get_num_loaders(&self) -> usize

Fetches the number of loaders.

unsafe fn get_num_exported_interfaces(&self) -> usize

Fetches the number of exported interfaces.

unsafe fn module_exists(&self, handle: ModuleHandle) -> Bool

Checks if a module exists.

unsafe fn type_exists(&self, mod_type: NonNullConst<ModuleType>) -> Bool

Checks if a module type exists.

unsafe fn exported_interface_exists(
    &self,
    interface: NonNullConst<InterfaceDescriptor>
) -> Bool

Checks whether an exported interface exists.

unsafe fn get_modules(
    &self,
    buffer: NonNull<MutSpan<ModuleInfo>>
) -> Result<usize, Error>

Copies the available module info into a buffer.

unsafe fn get_module_types(
    &self,
    buffer: NonNull<MutSpan<ModuleType>>
) -> Result<usize, Error>

Copies the available module types into a buffer.

unsafe fn get_exported_interfaces(
    &self,
    buffer: NonNull<MutSpan<InterfaceDescriptor>>
) -> Result<usize, Error>

Copies the descriptors of the exported interfaces into a buffer.

unsafe fn get_exported_interface_handle(
    &self,
    interface: NonNullConst<InterfaceDescriptor>
) -> Result<ModuleHandle, Error>

Fetches the module handle of the exported interface.

unsafe fn create_module_handle(&mut self) -> ModuleHandle

Creates a new unlinked module handle.

unsafe fn remove_module_handle(
    &mut self,
    handle: ModuleHandle
) -> Result<i8, Error>

Removes an existing module handle.

unsafe fn link_module(
    &mut self,
    handle: ModuleHandle,
    loader: LoaderHandle,
    internal: InternalHandle
) -> Result<i8, Error>

Links a module handle to an internal module handle.

unsafe fn get_internal_module_handle(
    &self,
    handle: ModuleHandle
) -> Result<InternalHandle, Error>

Fetches the internal handle linked with the module handle.

unsafe fn add_module(
    &mut self,
    loader: LoaderHandle,
    path: NonNullConst<OSPathChar>
) -> Result<ModuleHandle, Error>

Adds a new module.

unsafe fn remove_module(&mut self, handle: ModuleHandle) -> Result<i8, Error>

Removes a module.

unsafe fn load(&mut self, handle: ModuleHandle) -> Result<i8, Error>

Loads a module.

unsafe fn unload(&mut self, handle: ModuleHandle) -> Result<i8, Error>

Unloads a module.

unsafe fn initialize(&mut self, handle: ModuleHandle) -> Result<i8, Error>

Initializes a module.

unsafe fn terminate(&mut self, handle: ModuleHandle) -> Result<i8, Error>

Terminates a module.

unsafe fn add_dependency(
    &mut self,
    handle: ModuleHandle,
    interface: NonNullConst<InterfaceDescriptor>
) -> Result<i8, Error>

Registers a new runtime dependency of the module.

unsafe fn remove_dependency(
    &mut self,
    handle: ModuleHandle,
    interface: NonNullConst<InterfaceDescriptor>
) -> Result<i8, Error>

Removes an existing runtime dependency from the module.

unsafe fn export_interface(
    &mut self,
    handle: ModuleHandle,
    interface: NonNullConst<InterfaceDescriptor>
) -> Result<i8, Error>

Exports an interface of a module.

unsafe fn get_load_dependencies(
    &self,
    handle: ModuleHandle
) -> Result<ConstSpan<InterfaceDescriptor>, Error>

Fetches the load dependencies of a module.

unsafe fn get_runtime_dependencies(
    &self,
    handle: ModuleHandle
) -> Result<ConstSpan<InterfaceDescriptor>, Error>

Fetches the runtime dependencies of a module.

unsafe fn get_exportable_interfaces(
    &self,
    handle: ModuleHandle
) -> Result<ConstSpan<InterfaceDescriptor>, Error>

Fetches the exportable interfaces of a module.

unsafe fn fetch_status(
    &self,
    handle: ModuleHandle
) -> Result<ModuleStatus, Error>

Fetches the load status of a module.

unsafe fn get_module_path(
    &self,
    handle: ModuleHandle
) -> Result<NonNullConst<OSPathChar>, Error>

Fetches the path a module was loaded from.

unsafe fn get_module_info(
    &self,
    handle: ModuleHandle
) -> Result<NonNullConst<ModuleInfo>, Error>

Fetches the module info from a module.

unsafe fn get_interface(
    &self,
    handle: ModuleHandle,
    interface: NonNullConst<InterfaceDescriptor>
) -> Result<Interface, Error>

Fetches an interface from a module.

impl SysBinding for CBaseRef<'_>

unsafe fn shutdown(&mut self) -> !

Sends a termination signal.

unsafe fn panic(&self, error: Option<NonNullConst<u8>>) -> !

Execution of the program is stopped abruptly. The error may be logged.

unsafe fn has_function(&self, id: FnId) -> Bool

Checks if a function is implemented.

unsafe fn get_function(&self, id: FnId) -> Optional<fn()>

Fetches a function from the interface.

unsafe fn lock(&self)

Locks the interface.

unsafe fn try_lock(&self) -> Bool

Tries to lock the interface.

unsafe fn unlock(&self)

Unlocks the interface.

unsafe fn get_sync_handler(&self) -> NonNullConst<SyncHandlerInterface>

Fetches the active synchronization handler.

unsafe fn set_sync_handler(
    &mut self,
    handler: Option<NonNullConst<SyncHandlerInterface>>
)

Sets a new synchronization handler.

impl VersionBinding for CBaseRef<'_>

unsafe fn new_short(&self, major: i32, minor: i32, patch: i32) -> Version

Constructs a new version.

unsafe fn new_long(
    &self,
    major: i32,
    minor: i32,
    patch: i32,
    release_type: ReleaseType,
    release_number: i8
) -> Version

Constructs a new version.

unsafe fn new_full(
    &self,
    major: i32,
    minor: i32,
    patch: i32,
    release_type: ReleaseType,
    release_number: i8,
    build: i64
) -> Version

Constructs a new version.

unsafe fn from_string(
    &self,
    buffer: NonNullConst<ConstSpan<u8>>
) -> Result<Version, Error>

Constructs a version from a string.

unsafe fn string_length_short(&self, version: NonNullConst<Version>) -> usize

Computes the length of the short version string.

unsafe fn string_length_long(&self, version: NonNullConst<Version>) -> usize

Computes the length of the long version string.

unsafe fn string_length_full(&self, version: NonNullConst<Version>) -> usize

Computes the length of the full version string.

unsafe fn as_string_short(
    &self,
    version: NonNullConst<Version>,
    buffer: NonNull<MutSpan<u8>>
) -> Result<usize, Error>

Represents the version as a short string.

unsafe fn as_string_long(
    &self,
    version: NonNullConst<Version>,
    buffer: NonNull<MutSpan<u8>>
) -> Result<usize, Error>

Represents the version as a long string.

unsafe fn as_string_full(
    &self,
    version: NonNullConst<Version>,
    buffer: NonNull<MutSpan<u8>>
) -> Result<usize, Error>

Represents the version as a full string.

unsafe fn string_is_valid(
    &self,
    version_string: NonNullConst<ConstSpan<u8>>
) -> Bool

Checks whether the version string is valid.

unsafe fn compare(
    &self,
    lhs: NonNullConst<Version>,
    rhs: NonNullConst<Version>
) -> i32

Compares two versions.

unsafe fn compare_weak(
    &self,
    lhs: NonNullConst<Version>,
    rhs: NonNullConst<Version>
) -> i32

Compares two versions.

unsafe fn compare_strong(
    &self,
    lhs: NonNullConst<Version>,
    rhs: NonNullConst<Version>
) -> i32

Compares two versions.

unsafe fn is_compatible(
    &self,
    lhs: NonNullConst<Version>,
    rhs: NonNullConst<Version>
) -> Bool

Checks for compatibility of two versions.