Struct oo_bindgen::model::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 bi-directional 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>