Struct bindgen::Builder

source ·
pub struct Builder { /* private fields */ }
Expand description

Configure and generate Rust bindings for a C/C++ header.

This is the main entry point to the library.

use bindgen::builder;

// Configure and generate bindings.
let bindings = builder().header("path/to/input/header")
    .allowlist_type("SomeCoolClass")
    .allowlist_function("do_some_cool_thing")
    .generate()?;

// Write the generated bindings to an output file.
bindings.write_to_file("path/to/output.rs")?;

Enums

Bindgen can map C/C++ enums into Rust in different ways. The way bindgen maps enums depends on the pattern passed to several methods:

  1. constified_enum_module()
  2. bitfield_enum()
  3. newtype_enum()
  4. rustified_enum()

For each C enum, bindgen tries to match the pattern in the following order:

  1. Constified enum module
  2. Bitfield enum
  3. Newtype enum
  4. Rustified enum

If none of the above patterns match, then bindgen will generate a set of Rust constants.

Clang arguments

Extra arguments can be passed to with clang:

  1. clang_arg(): takes a single argument
  2. clang_args(): takes an iterator of arguments
  3. BINDGEN_EXTRA_CLANG_ARGS environment variable: whitespace separate environment variable of arguments

Clang arguments specific to your crate should be added via the clang_arg()/clang_args() methods.

End-users of the crate may need to set the BINDGEN_EXTRA_CLANG_ARGS environment variable to add additional arguments. For example, to build against a different sysroot a user could set BINDGEN_EXTRA_CLANG_ARGS to --sysroot=/path/to/sysroot.

Regular expression arguments

Some Builder methods like the allowlist_* and blocklist_* family of methods allow regular expressions as arguments. These regular expressions will be parenthesized and wrapped in ^ and $. So if <regex> is passed as argument, the regular expression to be stored will be ^(<regex>)$.

Releases of bindgen with a version lesser or equal to 0.62.0 used to accept the wildcard pattern * as a valid regular expression. This behavior has been deprecated and the .* pattern must be used instead.

Implementations§

source§

impl Builder

source

pub fn command_line_flags(&self) -> Vec<String>

Generates the command line flags use for creating Builder.

source

pub fn header<T: Into<String>>(self, header: T) -> Builder

Add an input C/C++ header to generate bindings for.

This can be used to generate bindings to a single header:

let bindings = bindgen::Builder::default()
    .header("input.h")
    .generate()
    .unwrap();

Or you can invoke it multiple times to generate bindings to multiple headers:

let bindings = bindgen::Builder::default()
    .header("first.h")
    .header("second.h")
    .header("third.h")
    .generate()
    .unwrap();
source

pub fn depfile<H: Into<String>, D: Into<PathBuf>>(
self,
output_module: H,
depfile: D
) -> Builder

Add a depfile output which will be written alongside the generated bindings.

source

pub fn header_contents(self, name: &str, contents: &str) -> Builder

Add contents as an input C/C++ header named name.

The file name will be added to the clang arguments.

source

pub fn rust_target(self, rust_target: RustTarget) -> Self

Specify the rust target

The default is the latest stable Rust version

source

pub fn disable_untagged_union(self) -> Self

Disable support for native Rust unions, if supported.

source

pub fn disable_header_comment(self) -> Self

Disable insertion of bindgen’s version identifier into generated bindings.

source

pub fn emit_ir_graphviz<T: Into<String>>(self, path: T) -> Builder

Set the output graphviz file.

source

pub fn generate_comments(self, doit: bool) -> Self

Whether the generated bindings should contain documentation comments (docstrings) or not. This is set to true by default.

Note that clang by default excludes comments from system headers, pass -fretain-comments-from-system-headers as clang_arg to include them. It can also be told to process all comments (not just documentation ones) using the -fparse-all-comments flag. See slides on clang comment parsing for background and examples.

source

pub fn allowlist_recursively(self, doit: bool) -> Self

Whether to allowlist recursively or not. Defaults to true.

Given that we have explicitly allowlisted the “initiate_dance_party” function in this C header:

typedef struct MoonBoots {
    int bouncy_level;
} MoonBoots;

void initiate_dance_party(MoonBoots* boots);

We would normally generate bindings to both the initiate_dance_party function and the MoonBoots struct that it transitively references. By configuring with allowlist_recursively(false), bindgen will not emit bindings for anything except the explicitly allowlisted items, and there would be no emitted struct definition for MoonBoots. However, the initiate_dance_party function would still reference MoonBoots!

Disabling this feature will almost certainly cause bindgen to emit bindings that will not compile! If you disable this feature, then it is your responsibility to provide definitions for every type that is referenced from an explicitly allowlisted item. One way to provide the definitions is by using the Builder::raw_line method, another would be to define them in Rust and then include!(...) the bindings immediately afterwards.

source

pub fn objc_extern_crate(self, doit: bool) -> Self

Generate #[macro_use] extern crate objc; instead of use objc; in the prologue of the files generated from objective-c files

source

pub fn generate_block(self, doit: bool) -> Self

Generate proper block signatures instead of void pointers.

source

pub fn block_extern_crate(self, doit: bool) -> Self

Generate #[macro_use] extern crate block; instead of use block; in the prologue of the files generated from apple block files

source

pub fn trust_clang_mangling(self, doit: bool) -> Self

Whether to use the clang-provided name mangling. This is true by default and probably needed for C++ features.

However, some old libclang versions seem to return incorrect results in some cases for non-mangled functions, see 1, so we allow disabling it.

source

pub fn blocklist_type<T: AsRef<str>>(self, arg: T) -> Builder

Hide the given type from the generated bindings. Regular expressions are supported.

To blocklist types prefixed with “mylib” use "mylib_.*". Check the regular expression arguments section and the regex crate documentation for further information.

source

pub fn blocklist_function<T: AsRef<str>>(self, arg: T) -> Builder

Hide the given function from the generated bindings. Regular expressions are supported.

Methods can be blocklisted by prefixing the name of the type implementing them followed by an underscore. So if Foo has a method bar, it can be blocklisted as Foo_bar.

To blocklist functions prefixed with “mylib” use "mylib_.*". Check the regular expression arguments section and the regex crate documentation for further information.

source

pub fn blocklist_item<T: AsRef<str>>(self, arg: T) -> Builder

Hide the given item from the generated bindings, regardless of whether it’s a type, function, module, etc. Regular expressions are supported.

To blocklist items prefixed with “mylib” use "mylib_.*". Check the regular expression arguments section and the regex crate documentation for further information.

source

pub fn blocklist_file<T: AsRef<str>>(self, arg: T) -> Builder

Hide any contents of the given file from the generated bindings, regardless of whether it’s a type, function, module etc. Check the regular expression arguments section and the regex crate documentation for further information.

source

pub fn opaque_type<T: AsRef<str>>(self, arg: T) -> Builder

Treat the given type as opaque in the generated bindings. Regular expressions are supported.

To change types prefixed with “mylib” into opaque, use "mylib_.*". Check the regular expression arguments section and the regex crate documentation for further information.

source

pub fn allowlist_type<T: AsRef<str>>(self, arg: T) -> Builder

Allowlist the given type so that it (and all types that it transitively refers to) appears in the generated bindings. Regular expressions are supported.

To allowlist types prefixed with “mylib” use "mylib_.*". Check the regular expression arguments section and the regex crate documentation for further information.

source

pub fn allowlist_function<T: AsRef<str>>(self, arg: T) -> Builder

Allowlist the given function so that it (and all types that it transitively refers to) appears in the generated bindings. Regular expressions are supported.

Methods can be allowlisted by prefixing the name of the type implementing them followed by an underscore. So if Foo has a method bar, it can be allowlisted as Foo_bar.

To allowlist functions prefixed with “mylib” use "mylib_.*". Check the regular expression arguments section and the regex crate documentation for further information.

source

pub fn allowlist_var<T: AsRef<str>>(self, arg: T) -> Builder

Allowlist the given variable so that it (and all types that it transitively refers to) appears in the generated bindings. Regular expressions are supported.

To allowlist variables prefixed with “mylib” use "mylib_.*". Check the regular expression arguments section and the regex crate documentation for further information.

source

pub fn allowlist_file<T: AsRef<str>>(self, arg: T) -> Builder

Allowlist the given file so that its contents appear in the generated bindings. Check the regular expression arguments section and the regex crate documentation for further information.

source

pub fn default_enum_style(self, arg: EnumVariation) -> Builder

Set the default style of code to generate for enums

source

pub fn bitfield_enum<T: AsRef<str>>(self, arg: T) -> Builder

Mark the given enum (or set of enums, if using a pattern) as being bitfield-like. Regular expressions are supported.

This makes bindgen generate a type that isn’t a rust enum. Regular expressions are supported.

This is similar to the newtype enum style, but with the bitwise operators implemented. Check the regular expression arguments section and the regex crate documentation for further information.

source

pub fn newtype_enum<T: AsRef<str>>(self, arg: T) -> Builder

Mark the given enum (or set of enums, if using a pattern) as a newtype. Regular expressions are supported.

This makes bindgen generate a type that isn’t a Rust enum. Regular expressions are supported. Check the regular expression arguments section and the regex crate documentation for further information.

source

pub fn newtype_global_enum<T: AsRef<str>>(self, arg: T) -> Builder

Mark the given enum (or set of enums, if using a pattern) as a newtype whose variants are exposed as global constants.

Regular expressions are supported.

This makes bindgen generate a type that isn’t a Rust enum. Regular expressions are supported. Check the regular expression arguments section and the regex crate documentation for further information.

source

pub fn rustified_enum<T: AsRef<str>>(self, arg: T) -> Builder

Mark the given enum (or set of enums, if using a pattern) as a Rust enum.

This makes bindgen generate enums instead of constants. Regular expressions are supported.

Use this with caution, creating this in unsafe code (including FFI) with an invalid value will invoke undefined behaviour. You may want to use the newtype enum style instead. Check the regular expression arguments section and the regex crate documentation for further information.

source

pub fn rustified_non_exhaustive_enum<T: AsRef<str>>(self, arg: T) -> Builder

Mark the given enum (or set of enums, if using a pattern) as a Rust enum with the #[non_exhaustive] attribute.

This makes bindgen generate enums instead of constants. Regular expressions are supported.

Use this with caution, creating this in unsafe code (including FFI) with an invalid value will invoke undefined behaviour. You may want to use the newtype enum style instead. Check the regular expression arguments section and the regex crate documentation for further information.

source

pub fn constified_enum<T: AsRef<str>>(self, arg: T) -> Builder

Mark the given enum (or set of enums, if using a pattern) as a set of constants that are not to be put into a module. Check the regular expression arguments section and the regex crate documentation for further information.

source

pub fn constified_enum_module<T: AsRef<str>>(self, arg: T) -> Builder

Mark the given enum (or set of enums, if using a pattern) as a set of constants that should be put into a module.

This makes bindgen generate modules containing constants instead of just constants. Regular expressions are supported. Check the regular expression arguments section and the regex crate documentation for further information.

source

pub fn default_macro_constant_type(self, arg: MacroTypeVariation) -> Builder

Set the default type for macro constants

source

pub fn default_alias_style(self, arg: AliasVariation) -> Builder

Set the default style of code to generate for typedefs

source

pub fn type_alias<T: AsRef<str>>(self, arg: T) -> Builder

Mark the given typedef alias (or set of aliases, if using a pattern) to use regular Rust type aliasing.

This is the default behavior and should be used if default_alias_style was set to NewType or NewTypeDeref and you want to override it for a set of typedefs. Check the regular expression arguments section and the regex crate documentation for further information.

source

pub fn new_type_alias<T: AsRef<str>>(self, arg: T) -> Builder

Mark the given typedef alias (or set of aliases, if using a pattern) to be generated as a new type by having the aliased type be wrapped in a #[repr(transparent)] struct.

Used to enforce stricter type checking. Check the regular expression arguments section and the regex crate documentation for further information.

source

pub fn new_type_alias_deref<T: AsRef<str>>(self, arg: T) -> Builder

Mark the given typedef alias (or set of aliases, if using a pattern) to be generated as a new type by having the aliased type be wrapped in a #[repr(transparent)] struct and also have an automatically generated impl’s of Deref and DerefMut to their aliased type. Check the regular expression arguments section and the regex crate documentation for further information.

source

pub fn default_non_copy_union_style(self, arg: NonCopyUnionStyle) -> Self

Set the default style of code to generate for unions with a non-Copy member.

source

pub fn bindgen_wrapper_union<T: AsRef<str>>(self, arg: T) -> Self

Mark the given union (or set of union, if using a pattern) to use a bindgen-generated wrapper for its members if at least one is non-Copy. Check the regular expression arguments section and the regex crate documentation for further information.

source

pub fn manually_drop_union<T: AsRef<str>>(self, arg: T) -> Self

Mark the given union (or set of union, if using a pattern) to use ::core::mem::ManuallyDrop for its members if at least one is non-Copy.

Note: ManuallyDrop was stabilized in Rust 1.20.0, do not use it if your MSRV is lower. Check the regular expression arguments section and the regex crate documentation for further information.

source

pub fn raw_line<T: Into<String>>(self, arg: T) -> Self

Add a string to prepend to the generated bindings. The string is passed through without any modification. Check the regular expression arguments section and the regex crate documentation for further information.

source

pub fn module_raw_line<T, U>(self, mod_: T, line: U) -> Selfwhere
T: Into<String>,
U: Into<String>,

Add a given line to the beginning of module mod.

source

pub fn module_raw_lines<T, I>(self, mod_: T, lines: I) -> Selfwhere
T: Into<String>,
I: IntoIterator,
I::Item: Into<String>,

Add a given set of lines to the beginning of module mod.

source

pub fn clang_arg<T: Into<String>>(self, arg: T) -> Builder

Add an argument to be passed straight through to clang.

source

pub fn clang_args<I>(self, iter: I) -> Builderwhere
I: IntoIterator,
I::Item: AsRef<str>,

Add arguments to be passed straight through to clang.

source

pub fn emit_builtins(self) -> Builder

Emit bindings for builtin definitions (for example __builtin_va_list) in the generated Rust.

source

pub fn no_convert_floats(self) -> Self

Avoid converting floats to f32/f64 by default.

source

pub fn layout_tests(self, doit: bool) -> Self

Set whether layout tests should be generated.

source

pub fn impl_debug(self, doit: bool) -> Self

Set whether Debug should be implemented, if it can not be derived automatically.

source

pub fn impl_partialeq(self, doit: bool) -> Self

Set whether PartialEq should be implemented, if it can not be derived automatically.

source

pub fn derive_copy(self, doit: bool) -> Self

Set whether Copy should be derived by default.

source

pub fn derive_debug(self, doit: bool) -> Self

Set whether Debug should be derived by default.

source

pub fn derive_default(self, doit: bool) -> Self

Set whether Default should be derived by default.

source

pub fn derive_hash(self, doit: bool) -> Self

Set whether Hash should be derived by default.

source

pub fn derive_partialord(self, doit: bool) -> Self

Set whether PartialOrd should be derived by default. If we don’t compute partialord, we also cannot compute ord. Set the derive_ord to false when doit is false.

source

pub fn derive_ord(self, doit: bool) -> Self

Set whether Ord should be derived by default. We can’t compute Ord without computing PartialOrd, so we set the same option to derive_partialord.

source

pub fn derive_partialeq(self, doit: bool) -> Self

Set whether PartialEq should be derived by default.

If we don’t derive PartialEq, we also cannot derive Eq, so deriving Eq is also disabled when doit is false.

source

pub fn derive_eq(self, doit: bool) -> Self

Set whether Eq should be derived by default.

We can’t derive Eq without also deriving PartialEq, so we also enable deriving PartialEq when doit is true.

source

pub fn time_phases(self, doit: bool) -> Self

Set whether or not to time bindgen phases, and print information to stderr.

source

pub fn emit_clang_ast(self) -> Builder

Emit Clang AST.

source

pub fn emit_ir(self) -> Builder

Emit IR.

source

pub fn enable_cxx_namespaces(self) -> Builder

Enable C++ namespaces.

source

pub fn enable_function_attribute_detection(self) -> Self

Enable detecting must_use attributes on C functions.

This is quite slow in some cases (see #1465), so it’s disabled by default.

Note that for this to do something meaningful for now at least, the rust target version has to have support for #[must_use].

source

pub fn disable_name_namespacing(self) -> Builder

Disable name auto-namespacing.

By default, bindgen mangles names like foo::bar::Baz to look like foo_bar_Baz instead of just Baz.

This method disables that behavior.

Note that this intentionally does not change the names used for allowlisting and blocklisting, which should still be mangled with the namespaces.

Note, also, that this option may cause bindgen to generate duplicate names.

source

pub fn disable_nested_struct_naming(self) -> Builder

Disable nested struct naming.

The following structs have different names for C and C++. In case of C they are visible as foo and bar. In case of C++ they are visible as foo and foo::bar.

struct foo {
    struct bar {
    } b;
};

Bindgen wants to avoid duplicate names by default so it follows C++ naming and it generates foo/foo_bar instead of just foo/bar.

This method disables this behavior and it is indented to be used only for headers that were written for C.

source

pub fn conservative_inline_namespaces(self) -> Builder

Treat inline namespaces conservatively.

This is tricky, because in C++ is technically legal to override an item defined in an inline namespace:

inline namespace foo {
    using Bar = int;
}
using Bar = long;

Even though referencing Bar is a compiler error.

We want to support this (arguably esoteric) use case, but we don’t want to make the rest of bindgen users pay an usability penalty for that.

To support this, we need to keep all the inline namespaces around, but then bindgen usage is a bit more difficult, because you cannot reference, e.g., std::string (you’d need to use the proper inline namespace).

We could complicate a lot of the logic to detect name collisions, and if not detected generate a pub use inline_ns::* or something like that.

That’s probably something we can do if we see this option is needed in a lot of cases, to improve it’s usability, but my guess is that this is not going to be too useful.

source

pub fn generate_inline_functions(self, doit: bool) -> Self

Whether inline functions should be generated or not.

Note that they will usually not work. However you can use -fkeep-inline-functions or -fno-inline-functions if you are responsible of compiling the library to make them callable.

source

pub fn ignore_functions(self) -> Builder

Ignore functions.

source

pub fn ignore_methods(self) -> Builder

Ignore methods.

source

pub fn use_core(self) -> Builder

Use core instead of libstd in the generated bindings.

source

pub fn ctypes_prefix<T: Into<String>>(self, prefix: T) -> Builder

Use the given prefix for the raw types instead of ::std::os::raw.

source

pub fn anon_fields_prefix<T: Into<String>>(self, prefix: T) -> Builder

Use the given prefix for the anon fields.

source

pub fn parse_callbacks(self, cb: Box<dyn ParseCallbacks>) -> Self

Allows configuring types in different situations, see the ParseCallbacks documentation.

source

pub fn with_codegen_config(self, config: CodegenConfig) -> Self

Choose what to generate using a CodegenConfig.

source

pub fn detect_include_paths(self, doit: bool) -> Self

Whether to detect include paths using clang_sys.

source

pub fn fit_macro_constants(self, doit: bool) -> Self

Whether to try to fit macro constants to types smaller than u32/i32

source

pub fn prepend_enum_name(self, doit: bool) -> Self

Prepend the enum name to constant or newtype variants.

source

pub fn size_t_is_usize(self, is: bool) -> Self

Set whether size_t should be translated to usize automatically.

source

pub fn rustfmt_bindings(self, doit: bool) -> Self

Set whether rustfmt should format the generated bindings.

source

pub fn record_matches(self, doit: bool) -> Self

Set whether we should record matched items in our regex sets.

source

pub fn rustfmt_configuration_file(self, path: Option<PathBuf>) -> Self

Set the absolute path to the rustfmt configuration file, if None, the standard rustfmt options are used.

source

pub fn with_rustfmt<P: Into<PathBuf>>(self, path: P) -> Self

Sets an explicit path to rustfmt, to be used when rustfmt is enabled.

source

pub fn explicit_padding(self, doit: bool) -> Self

If true, always emit explicit padding fields.

If a struct needs to be serialized in its native format (padding bytes and all), for example writing it to a file or sending it on the network, then this should be enabled, as anything reading the padding bytes of a struct may lead to Undefined Behavior.

source

pub fn vtable_generation(self, doit: bool) -> Self

If true, enables experimental support to generate vtable functions.

Should mostly work, though some edge cases are likely to be broken.

source

pub fn sort_semantically(self, doit: bool) -> Self

If true, enables the sorting of the output in a predefined manner.

TODO: Perhaps move the sorting order out into a config

source

pub fn merge_extern_blocks(self, doit: bool) -> Self

If true, merges extern blocks.

source

pub fn generate(self) -> Result<Bindings, BindgenError>

Generate the Rust bindings using the options built up thus far.

source

pub fn dump_preprocessed_input(&self) -> Result<()>

Preprocess and dump the input header files to disk.

This is useful when debugging bindgen, using C-Reduce, or when filing issues. The resulting file will be named something like __bindgen.i or __bindgen.ii

source

pub fn no_partialeq<T: Into<String>>(self, arg: T) -> Builder

Don’t derive PartialEq for a given type. Regular expressions are supported. Check the regular expression arguments section and the regex crate documentation for further information.

source

pub fn no_copy<T: Into<String>>(self, arg: T) -> Self

Don’t derive Copy for a given type. Regular expressions are supported. Check the regular expression arguments section and the regex crate documentation for further information.

source

pub fn no_debug<T: Into<String>>(self, arg: T) -> Self

Don’t derive Debug for a given type. Regular expressions are supported. Check the regular expression arguments section and the regex crate documentation for further information.

source

pub fn no_default<T: Into<String>>(self, arg: T) -> Self

Don’t derive/impl Default for a given type. Regular expressions are supported. Check the regular expression arguments section and the regex crate documentation for further information.

source

pub fn no_hash<T: Into<String>>(self, arg: T) -> Builder

Don’t derive Hash for a given type. Regular expressions are supported. Check the regular expression arguments section and the regex crate documentation for further information.

source

pub fn must_use_type<T: Into<String>>(self, arg: T) -> Builder

Add #[must_use] for the given type. Regular expressions are supported. Check the regular expression arguments section and the regex crate documentation for further information.

source

pub fn array_pointers_in_arguments(self, doit: bool) -> Self

Set whether arr[size] should be treated as *mut T or *mut [T; size] (same for mut)

source

pub fn wasm_import_module_name<T: Into<String>>(self, import_name: T) -> Self

Set the wasm import module name

source

pub fn dynamic_library_name<T: Into<String>>(
self,
dynamic_library_name: T
) -> Self

Specify the dynamic library name if we are generating bindings for a shared library.

Require successful linkage for all routines in a shared library. This allows us to optimize function calls by being able to safely assume function pointers are valid.

source

pub fn respect_cxx_access_specs(self, doit: bool) -> Self

Generate bindings as pub only if the bound item is publically accessible by C++.

source

pub fn translate_enum_integer_types(self, doit: bool) -> Self

Always translate enum integer types to native Rust integer types.

This will result in enums having types such as u32 and i16 instead of c_uint and c_short. Types for Rustified enums are always translated.

source

pub fn c_naming(self, doit: bool) -> Self

Generate types with C style naming.

This will add prefixes to the generated type names. For example instead of a struct A we will generate struct struct_A. Currently applies to structs, unions, and enums.

source

pub fn override_abi<T: Into<String>>(self, abi: Abi, arg: T) -> Self

Override the ABI of a given function. Regular expressions are supported.

source

pub fn wrap_unsafe_ops(self, doit: bool) -> Self

If true, wraps unsafe operations in unsafe blocks.

Trait Implementations§

source§

impl Clone for Builder

source§

fn clone(&self) -> Builder

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from source. Read more
source§

impl Debug for Builder

source§

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

Formats the value using the given formatter. Read more
source§

impl Default for Builder

source§

fn default() -> Builder

Returns the “default value” for a type. Read more

Auto Trait Implementations§

§

impl !RefUnwindSafe for Builder

§

impl !Send for Builder

§

impl !Sync for Builder

§

impl Unpin for Builder

§

impl !UnwindSafe for Builder

Blanket Implementations§

source§

impl<T> Any for Twhere
T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for Twhere
T: ?Sized,

const: unstable · source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for Twhere
T: ?Sized,

const: unstable · source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

const: unstable · source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for Twhere
U: From<T>,

const: unstable · source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T> ToOwned for Twhere
T: Clone,

§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T, U> TryFrom<U> for Twhere
U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
const: unstable · source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for Twhere
U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
const: unstable · source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.