Struct CBaseRef

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

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.