Struct LibraryBuilder

pub struct LibraryBuilder { /* private fields */ }

Implementations

impl LibraryBuilder

pub fn new( version: Version, info: LibraryInfo, settings: Rc<LibrarySettings>, ) -> Self

pub fn build(self) -> BindResult<Library>

pub fn define_error_type<T: IntoName>( &mut self, error_name: T, exception_name: T, exception_type: ExceptionType, ) -> BindResult<ErrorTypeBuilder<'_>>

pub fn define_constants<T: IntoName>( &mut self, name: T, ) -> BindResult<ConstantSetBuilder<'_>>

pub fn declare_universal_struct<T: IntoName>( &mut self, name: T, ) -> BindResult<UniversalStructDeclaration>

pub fn declare_function_argument_struct<T: IntoName>( &mut self, name: T, ) -> BindResult<FunctionArgStructDeclaration>

pub fn declare_function_return_struct<T: IntoName>( &mut self, name: T, ) -> BindResult<FunctionReturnStructDeclaration>

pub fn declare_callback_argument_struct<T: IntoName>( &mut self, name: T, ) -> BindResult<CallbackArgStructDeclaration>

pub fn define_universal_struct( &mut self, declaration: UniversalStructDeclaration, ) -> BindResult<UniversalStructBuilder<'_>>

Define a structure that can be used in any context.

Backends will generate bidirectional conversion routines for this type of struct.

pub fn define_opaque_struct( &mut self, declaration: UniversalStructDeclaration, ) -> BindResult<UniversalStructBuilder<'_>>

Define an opaque structure which must be of universal type

pub fn define_callback_argument_struct<T>( &mut self, declaration: T, ) -> BindResult<CallbackArgStructBuilder<'_>>

where T: Into<CallbackArgStructDeclaration>,

Define a structure that can be only be used in callback function arguments

pub fn define_function_return_struct<T>( &mut self, declaration: T, ) -> BindResult<FunctionReturnStructBuilder<'_>>

where T: Into<FunctionReturnStructDeclaration>,

Define a structure that can only be used as function return value

pub fn define_function_argument_struct<T>( &mut self, declaration: T, ) -> BindResult<FunctionArgStructBuilder<'_>>

where T: Into<FunctionArgStructDeclaration>,

Define a structure that can only be be used as a function argument

pub fn define_enum<T: IntoName>( &mut self, name: T, ) -> BindResult<EnumBuilder<'_>>

Define an enumeration

pub fn define_function<T: IntoName>( &mut self, name: T, ) -> BindResult<FunctionBuilder<'_>>

pub fn define_method<T: IntoName>( &mut self, name: T, class: ClassDeclarationHandle, ) -> BindResult<ClassMethodBuilder<'_>>

pub fn define_future_method<T: IntoName>( &mut self, name: T, class: ClassDeclarationHandle, future: FutureInterface<Unvalidated>, ) -> BindResult<FutureMethodBuilder<'_>>

pub fn define_constructor( &mut self, class: ClassDeclarationHandle, ) -> BindResult<ClassConstructorBuilder<'_>>

pub fn define_destructor<D: Into<Doc<Unvalidated>>>( &mut self, class: ClassDeclarationHandle, doc: D, ) -> BindResult<ClassDestructor<Unvalidated>>

pub fn declare_class<T: IntoName>( &mut self, name: T, ) -> BindResult<ClassDeclarationHandle>

pub fn define_class( &mut self, declaration: &ClassDeclarationHandle, ) -> BindResult<ClassBuilder<'_>>

pub fn define_static_class<T: IntoName>( &mut self, name: T, ) -> BindResult<StaticClassBuilder<'_>>

pub fn define_future_interface<T: IntoName, D: Into<Doc<Unvalidated>>, E: Into<DocString<Unvalidated>>, V: Into<CallbackArgument>>( &mut self, name: T, interface_docs: D, value_type: V, value_type_docs: E, error_type: ErrorType<Unvalidated>, ) -> BindResult<FutureInterface<Unvalidated>>

A future interface is a specialized asynchronous which consists of a single callback method providing a single value. The callback represents the completion of a “future” and is mapped appropriately in backends.

pub fn define_interface<T: IntoName, D: Into<Doc<Unvalidated>>>( &mut self, name: T, doc: D, ) -> BindResult<InterfaceBuilder<'_>>

pub fn define_iterator<N: IntoName, T: Into<IteratorItemType>>( &mut self, class_name: N, item_type: T, ) -> BindResult<AbstractIteratorHandle>

pub fn define_iterator_with_lifetime<N: IntoName, T: Into<IteratorItemType>>( &mut self, class_name: N, item_type: T, ) -> BindResult<AbstractIteratorHandle>

pub fn define_collection<N: IntoName, A: Into<FunctionArgument>>( &mut self, class_name: N, value_type: A, has_reserve: bool, ) -> BindResult<CollectionHandle>