Struct elrond_wasm_node::Box 1.0.0[−][src]
Expand description
A pointer type for heap allocation.
See the module-level documentation for more.
Implementations
impl<T> Box<T, Global>
[src]
impl<T> Box<T, Global>
[src]pub fn new(x: T) -> Box<T, Global>ⓘ
[src]
pub fn new(x: T) -> Box<T, Global>ⓘ
[src]Allocates memory on the heap and then places x
into it.
This doesn’t actually allocate if T
is zero-sized.
Examples
let five = Box::new(5);
pub fn new_uninit() -> Box<MaybeUninit<T>, Global>ⓘ
[src]
🔬 This is a nightly-only experimental API. (new_uninit
)
pub fn new_uninit() -> Box<MaybeUninit<T>, Global>ⓘ
[src]new_uninit
)Constructs a new box with uninitialized contents.
Examples
#![feature(new_uninit)] let mut five = Box::<u32>::new_uninit(); let five = unsafe { // Deferred initialization: five.as_mut_ptr().write(5); five.assume_init() }; assert_eq!(*five, 5)
pub fn new_zeroed() -> Box<MaybeUninit<T>, Global>ⓘ
[src]
🔬 This is a nightly-only experimental API. (new_uninit
)
pub fn new_zeroed() -> Box<MaybeUninit<T>, Global>ⓘ
[src]new_uninit
)Constructs a new Box
with uninitialized contents, with the memory
being filled with 0
bytes.
See MaybeUninit::zeroed
for examples of correct and incorrect usage
of this method.
Examples
#![feature(new_uninit)] let zero = Box::<u32>::new_zeroed(); let zero = unsafe { zero.assume_init() }; assert_eq!(*zero, 0)
pub fn pin(x: T) -> Pin<Box<T, Global>>
1.33.0[src]
pub fn pin(x: T) -> Pin<Box<T, Global>>
1.33.0[src]Constructs a new Pin<Box<T>>
. If T
does not implement Unpin
, then
x
will be pinned in memory and unable to be moved.
pub fn try_new(x: T) -> Result<Box<T, Global>, AllocError>
[src]
🔬 This is a nightly-only experimental API. (allocator_api
)
pub fn try_new(x: T) -> Result<Box<T, Global>, AllocError>
[src]allocator_api
)Allocates memory on the heap then places x
into it,
returning an error if the allocation fails
This doesn’t actually allocate if T
is zero-sized.
Examples
#![feature(allocator_api)] let five = Box::try_new(5)?;
pub fn try_new_uninit() -> Result<Box<MaybeUninit<T>, Global>, AllocError>
[src]
🔬 This is a nightly-only experimental API. (allocator_api
)
pub fn try_new_uninit() -> Result<Box<MaybeUninit<T>, Global>, AllocError>
[src]allocator_api
)Constructs a new box with uninitialized contents on the heap, returning an error if the allocation fails
Examples
#![feature(allocator_api, new_uninit)] let mut five = Box::<u32>::try_new_uninit()?; let five = unsafe { // Deferred initialization: five.as_mut_ptr().write(5); five.assume_init() }; assert_eq!(*five, 5);
pub fn try_new_zeroed() -> Result<Box<MaybeUninit<T>, Global>, AllocError>
[src]
🔬 This is a nightly-only experimental API. (allocator_api
)
pub fn try_new_zeroed() -> Result<Box<MaybeUninit<T>, Global>, AllocError>
[src]allocator_api
)Constructs a new Box
with uninitialized contents, with the memory
being filled with 0
bytes on the heap
See MaybeUninit::zeroed
for examples of correct and incorrect usage
of this method.
Examples
#![feature(allocator_api, new_uninit)] let zero = Box::<u32>::try_new_zeroed()?; let zero = unsafe { zero.assume_init() }; assert_eq!(*zero, 0);
impl<T, A> Box<T, A> where
A: Allocator,
[src]
impl<T, A> Box<T, A> where
A: Allocator,
[src]pub fn new_in(x: T, alloc: A) -> Box<T, A>ⓘ
[src]
🔬 This is a nightly-only experimental API. (allocator_api
)
pub fn new_in(x: T, alloc: A) -> Box<T, A>ⓘ
[src]allocator_api
)Allocates memory in the given allocator then places x
into it.
This doesn’t actually allocate if T
is zero-sized.
Examples
#![feature(allocator_api)] use std::alloc::System; let five = Box::new_in(5, System);
pub fn try_new_in(x: T, alloc: A) -> Result<Box<T, A>, AllocError>
[src]
🔬 This is a nightly-only experimental API. (allocator_api
)
pub fn try_new_in(x: T, alloc: A) -> Result<Box<T, A>, AllocError>
[src]allocator_api
)Allocates memory in the given allocator then places x
into it,
returning an error if the allocation fails
This doesn’t actually allocate if T
is zero-sized.
Examples
#![feature(allocator_api)] use std::alloc::System; let five = Box::try_new_in(5, System)?;
pub fn new_uninit_in(alloc: A) -> Box<MaybeUninit<T>, A>ⓘ
[src]
🔬 This is a nightly-only experimental API. (allocator_api
)
pub fn new_uninit_in(alloc: A) -> Box<MaybeUninit<T>, A>ⓘ
[src]allocator_api
)Constructs a new box with uninitialized contents in the provided allocator.
Examples
#![feature(allocator_api, new_uninit)] use std::alloc::System; let mut five = Box::<u32, _>::new_uninit_in(System); let five = unsafe { // Deferred initialization: five.as_mut_ptr().write(5); five.assume_init() }; assert_eq!(*five, 5)
pub fn try_new_uninit_in(alloc: A) -> Result<Box<MaybeUninit<T>, A>, AllocError>
[src]
🔬 This is a nightly-only experimental API. (allocator_api
)
pub fn try_new_uninit_in(alloc: A) -> Result<Box<MaybeUninit<T>, A>, AllocError>
[src]allocator_api
)Constructs a new box with uninitialized contents in the provided allocator, returning an error if the allocation fails
Examples
#![feature(allocator_api, new_uninit)] use std::alloc::System; let mut five = Box::<u32, _>::try_new_uninit_in(System)?; let five = unsafe { // Deferred initialization: five.as_mut_ptr().write(5); five.assume_init() }; assert_eq!(*five, 5);
pub fn new_zeroed_in(alloc: A) -> Box<MaybeUninit<T>, A>ⓘ
[src]
🔬 This is a nightly-only experimental API. (allocator_api
)
pub fn new_zeroed_in(alloc: A) -> Box<MaybeUninit<T>, A>ⓘ
[src]allocator_api
)Constructs a new Box
with uninitialized contents, with the memory
being filled with 0
bytes in the provided allocator.
See MaybeUninit::zeroed
for examples of correct and incorrect usage
of this method.
Examples
#![feature(allocator_api, new_uninit)] use std::alloc::System; let zero = Box::<u32, _>::new_zeroed_in(System); let zero = unsafe { zero.assume_init() }; assert_eq!(*zero, 0)
pub fn try_new_zeroed_in(alloc: A) -> Result<Box<MaybeUninit<T>, A>, AllocError>
[src]
🔬 This is a nightly-only experimental API. (allocator_api
)
pub fn try_new_zeroed_in(alloc: A) -> Result<Box<MaybeUninit<T>, A>, AllocError>
[src]allocator_api
)Constructs a new Box
with uninitialized contents, with the memory
being filled with 0
bytes in the provided allocator,
returning an error if the allocation fails,
See MaybeUninit::zeroed
for examples of correct and incorrect usage
of this method.
Examples
#![feature(allocator_api, new_uninit)] use std::alloc::System; let zero = Box::<u32, _>::try_new_zeroed_in(System)?; let zero = unsafe { zero.assume_init() }; assert_eq!(*zero, 0);
pub fn pin_in(x: T, alloc: A) -> Pin<Box<T, A>> where
A: 'static,
[src]
🔬 This is a nightly-only experimental API. (allocator_api
)
pub fn pin_in(x: T, alloc: A) -> Pin<Box<T, A>> where
A: 'static,
[src]allocator_api
)Constructs a new Pin<Box<T, A>>
. If T
does not implement Unpin
, then
x
will be pinned in memory and unable to be moved.
pub fn into_boxed_slice(boxed: Box<T, A>) -> Box<[T], A>ⓘ
[src]
🔬 This is a nightly-only experimental API. (box_into_boxed_slice
)
pub fn into_boxed_slice(boxed: Box<T, A>) -> Box<[T], A>ⓘ
[src]box_into_boxed_slice
)Converts a Box<T>
into a Box<[T]>
This conversion does not allocate on the heap and happens in place.
pub fn into_inner(boxed: Box<T, A>) -> T
[src]
🔬 This is a nightly-only experimental API. (box_into_inner
)
pub fn into_inner(boxed: Box<T, A>) -> T
[src]box_into_inner
)Consumes the Box
, returning the wrapped value.
Examples
#![feature(box_into_inner)] let c = Box::new(5); assert_eq!(Box::into_inner(c), 5);
impl<T> Box<[T], Global>
[src]
impl<T> Box<[T], Global>
[src]pub fn new_uninit_slice(len: usize) -> Box<[MaybeUninit<T>], Global>ⓘ
[src]
🔬 This is a nightly-only experimental API. (new_uninit
)
pub fn new_uninit_slice(len: usize) -> Box<[MaybeUninit<T>], Global>ⓘ
[src]new_uninit
)Constructs a new boxed slice with uninitialized contents.
Examples
#![feature(new_uninit)] let mut values = Box::<[u32]>::new_uninit_slice(3); let values = unsafe { // Deferred initialization: values[0].as_mut_ptr().write(1); values[1].as_mut_ptr().write(2); values[2].as_mut_ptr().write(3); values.assume_init() }; assert_eq!(*values, [1, 2, 3])
pub fn new_zeroed_slice(len: usize) -> Box<[MaybeUninit<T>], Global>ⓘ
[src]
🔬 This is a nightly-only experimental API. (new_uninit
)
pub fn new_zeroed_slice(len: usize) -> Box<[MaybeUninit<T>], Global>ⓘ
[src]new_uninit
)Constructs a new boxed slice with uninitialized contents, with the memory
being filled with 0
bytes.
See MaybeUninit::zeroed
for examples of correct and incorrect usage
of this method.
Examples
#![feature(new_uninit)] let values = Box::<[u32]>::new_zeroed_slice(3); let values = unsafe { values.assume_init() }; assert_eq!(*values, [0, 0, 0])
impl<T, A> Box<[T], A> where
A: Allocator,
[src]
impl<T, A> Box<[T], A> where
A: Allocator,
[src]pub fn new_uninit_slice_in(len: usize, alloc: A) -> Box<[MaybeUninit<T>], A>ⓘ
[src]
🔬 This is a nightly-only experimental API. (allocator_api
)
pub fn new_uninit_slice_in(len: usize, alloc: A) -> Box<[MaybeUninit<T>], A>ⓘ
[src]allocator_api
)Constructs a new boxed slice with uninitialized contents in the provided allocator.
Examples
#![feature(allocator_api, new_uninit)] use std::alloc::System; let mut values = Box::<[u32], _>::new_uninit_slice_in(3, System); let values = unsafe { // Deferred initialization: values[0].as_mut_ptr().write(1); values[1].as_mut_ptr().write(2); values[2].as_mut_ptr().write(3); values.assume_init() }; assert_eq!(*values, [1, 2, 3])
pub fn new_zeroed_slice_in(len: usize, alloc: A) -> Box<[MaybeUninit<T>], A>ⓘ
[src]
🔬 This is a nightly-only experimental API. (allocator_api
)
pub fn new_zeroed_slice_in(len: usize, alloc: A) -> Box<[MaybeUninit<T>], A>ⓘ
[src]allocator_api
)Constructs a new boxed slice with uninitialized contents in the provided allocator,
with the memory being filled with 0
bytes.
See MaybeUninit::zeroed
for examples of correct and incorrect usage
of this method.
Examples
#![feature(allocator_api, new_uninit)] use std::alloc::System; let values = Box::<[u32], _>::new_zeroed_slice_in(3, System); let values = unsafe { values.assume_init() }; assert_eq!(*values, [0, 0, 0])
impl<T, A> Box<MaybeUninit<T>, A> where
A: Allocator,
[src]
impl<T, A> Box<MaybeUninit<T>, A> where
A: Allocator,
[src]pub unsafe fn assume_init(self) -> Box<T, A>ⓘ
[src]
🔬 This is a nightly-only experimental API. (new_uninit
)
pub unsafe fn assume_init(self) -> Box<T, A>ⓘ
[src]new_uninit
)Converts to Box<T, A>
.
Safety
As with MaybeUninit::assume_init
,
it is up to the caller to guarantee that the value
really is in an initialized state.
Calling this when the content is not yet fully initialized
causes immediate undefined behavior.
Examples
#![feature(new_uninit)] let mut five = Box::<u32>::new_uninit(); let five: Box<u32> = unsafe { // Deferred initialization: five.as_mut_ptr().write(5); five.assume_init() }; assert_eq!(*five, 5)
impl<T, A> Box<[MaybeUninit<T>], A> where
A: Allocator,
[src]
impl<T, A> Box<[MaybeUninit<T>], A> where
A: Allocator,
[src]pub unsafe fn assume_init(self) -> Box<[T], A>ⓘ
[src]
🔬 This is a nightly-only experimental API. (new_uninit
)
pub unsafe fn assume_init(self) -> Box<[T], A>ⓘ
[src]new_uninit
)Converts to Box<[T], A>
.
Safety
As with MaybeUninit::assume_init
,
it is up to the caller to guarantee that the values
really are in an initialized state.
Calling this when the content is not yet fully initialized
causes immediate undefined behavior.
Examples
#![feature(new_uninit)] let mut values = Box::<[u32]>::new_uninit_slice(3); let values = unsafe { // Deferred initialization: values[0].as_mut_ptr().write(1); values[1].as_mut_ptr().write(2); values[2].as_mut_ptr().write(3); values.assume_init() }; assert_eq!(*values, [1, 2, 3])
impl<T> Box<T, Global> where
T: ?Sized,
[src]
impl<T> Box<T, Global> where
T: ?Sized,
[src]pub unsafe fn from_raw(raw: *mut T) -> Box<T, Global>ⓘ
1.4.0[src]
pub unsafe fn from_raw(raw: *mut T) -> Box<T, Global>ⓘ
1.4.0[src]Constructs a box from a raw pointer.
After calling this function, the raw pointer is owned by the
resulting Box
. Specifically, the Box
destructor will call
the destructor of T
and free the allocated memory. For this
to be safe, the memory must have been allocated in accordance
with the memory layout used by Box
.
Safety
This function is unsafe because improper use may lead to memory problems. For example, a double-free may occur if the function is called twice on the same raw pointer.
The safety conditions are described in the memory layout section.
Examples
Recreate a Box
which was previously converted to a raw pointer
using Box::into_raw
:
let x = Box::new(5); let ptr = Box::into_raw(x); let x = unsafe { Box::from_raw(ptr) };
Manually create a Box
from scratch by using the global allocator:
use std::alloc::{alloc, Layout}; unsafe { let ptr = alloc(Layout::new::<i32>()) as *mut i32; // In general .write is required to avoid attempting to destruct // the (uninitialized) previous contents of `ptr`, though for this // simple example `*ptr = 5` would have worked as well. ptr.write(5); let x = Box::from_raw(ptr); }
impl<T, A> Box<T, A> where
T: ?Sized,
A: Allocator,
[src]
impl<T, A> Box<T, A> where
T: ?Sized,
A: Allocator,
[src]pub unsafe fn from_raw_in(raw: *mut T, alloc: A) -> Box<T, A>ⓘ
[src]
🔬 This is a nightly-only experimental API. (allocator_api
)
pub unsafe fn from_raw_in(raw: *mut T, alloc: A) -> Box<T, A>ⓘ
[src]allocator_api
)Constructs a box from a raw pointer in the given allocator.
After calling this function, the raw pointer is owned by the
resulting Box
. Specifically, the Box
destructor will call
the destructor of T
and free the allocated memory. For this
to be safe, the memory must have been allocated in accordance
with the memory layout used by Box
.
Safety
This function is unsafe because improper use may lead to memory problems. For example, a double-free may occur if the function is called twice on the same raw pointer.
Examples
Recreate a Box
which was previously converted to a raw pointer
using Box::into_raw_with_allocator
:
#![feature(allocator_api)] use std::alloc::System; let x = Box::new_in(5, System); let (ptr, alloc) = Box::into_raw_with_allocator(x); let x = unsafe { Box::from_raw_in(ptr, alloc) };
Manually create a Box
from scratch by using the system allocator:
#![feature(allocator_api, slice_ptr_get)] use std::alloc::{Allocator, Layout, System}; unsafe { let ptr = System.allocate(Layout::new::<i32>())?.as_mut_ptr() as *mut i32; // In general .write is required to avoid attempting to destruct // the (uninitialized) previous contents of `ptr`, though for this // simple example `*ptr = 5` would have worked as well. ptr.write(5); let x = Box::from_raw_in(ptr, System); }
pub fn into_raw(b: Box<T, A>) -> *mut T
1.4.0[src]
pub fn into_raw(b: Box<T, A>) -> *mut T
1.4.0[src]Consumes the Box
, returning a wrapped raw pointer.
The pointer will be properly aligned and non-null.
After calling this function, the caller is responsible for the
memory previously managed by the Box
. In particular, the
caller should properly destroy T
and release the memory, taking
into account the memory layout used by Box
. The easiest way to
do this is to convert the raw pointer back into a Box
with the
Box::from_raw
function, allowing the Box
destructor to perform
the cleanup.
Note: this is an associated function, which means that you have
to call it as Box::into_raw(b)
instead of b.into_raw()
. This
is so that there is no conflict with a method on the inner type.
Examples
Converting the raw pointer back into a Box
with Box::from_raw
for automatic cleanup:
let x = Box::new(String::from("Hello")); let ptr = Box::into_raw(x); let x = unsafe { Box::from_raw(ptr) };
Manual cleanup by explicitly running the destructor and deallocating the memory:
use std::alloc::{dealloc, Layout}; use std::ptr; let x = Box::new(String::from("Hello")); let p = Box::into_raw(x); unsafe { ptr::drop_in_place(p); dealloc(p as *mut u8, Layout::new::<String>()); }
pub fn into_raw_with_allocator(b: Box<T, A>) -> (*mut T, A)
[src]
🔬 This is a nightly-only experimental API. (allocator_api
)
pub fn into_raw_with_allocator(b: Box<T, A>) -> (*mut T, A)
[src]allocator_api
)Consumes the Box
, returning a wrapped raw pointer and the allocator.
The pointer will be properly aligned and non-null.
After calling this function, the caller is responsible for the
memory previously managed by the Box
. In particular, the
caller should properly destroy T
and release the memory, taking
into account the memory layout used by Box
. The easiest way to
do this is to convert the raw pointer back into a Box
with the
Box::from_raw_in
function, allowing the Box
destructor to perform
the cleanup.
Note: this is an associated function, which means that you have
to call it as Box::into_raw_with_allocator(b)
instead of b.into_raw_with_allocator()
. This
is so that there is no conflict with a method on the inner type.
Examples
Converting the raw pointer back into a Box
with Box::from_raw_in
for automatic cleanup:
#![feature(allocator_api)] use std::alloc::System; let x = Box::new_in(String::from("Hello"), System); let (ptr, alloc) = Box::into_raw_with_allocator(x); let x = unsafe { Box::from_raw_in(ptr, alloc) };
Manual cleanup by explicitly running the destructor and deallocating the memory:
#![feature(allocator_api)] use std::alloc::{Allocator, Layout, System}; use std::ptr::{self, NonNull}; let x = Box::new_in(String::from("Hello"), System); let (ptr, alloc) = Box::into_raw_with_allocator(x); unsafe { ptr::drop_in_place(ptr); let non_null = NonNull::new_unchecked(ptr); alloc.deallocate(non_null.cast(), Layout::new::<String>()); }
pub fn allocator(b: &Box<T, A>) -> &A
[src]
🔬 This is a nightly-only experimental API. (allocator_api
)
pub fn allocator(b: &Box<T, A>) -> &A
[src]allocator_api
)Returns a reference to the underlying allocator.
Note: this is an associated function, which means that you have
to call it as Box::allocator(&b)
instead of b.allocator()
. This
is so that there is no conflict with a method on the inner type.
pub fn leak<'a>(b: Box<T, A>) -> &'a mut T where
A: 'a,
1.26.0[src]
pub fn leak<'a>(b: Box<T, A>) -> &'a mut T where
A: 'a,
1.26.0[src]Consumes and leaks the Box
, returning a mutable reference,
&'a mut T
. Note that the type T
must outlive the chosen lifetime
'a
. If the type has only static references, or none at all, then this
may be chosen to be 'static
.
This function is mainly useful for data that lives for the remainder of
the program’s life. Dropping the returned reference will cause a memory
leak. If this is not acceptable, the reference should first be wrapped
with the Box::from_raw
function producing a Box
. This Box
can
then be dropped which will properly destroy T
and release the
allocated memory.
Note: this is an associated function, which means that you have
to call it as Box::leak(b)
instead of b.leak()
. This
is so that there is no conflict with a method on the inner type.
Examples
Simple usage:
let x = Box::new(41); let static_ref: &'static mut usize = Box::leak(x); *static_ref += 1; assert_eq!(*static_ref, 42);
Unsized data:
let x = vec![1, 2, 3].into_boxed_slice(); let static_ref = Box::leak(x); static_ref[0] = 4; assert_eq!(*static_ref, [4, 2, 3]);
impl<A> Box<dyn Any + 'static, A> where
A: Allocator,
[src]
impl<A> Box<dyn Any + 'static, A> where
A: Allocator,
[src]pub fn downcast<T>(self) -> Result<Box<T, A>, Box<dyn Any + 'static, A>> where
T: Any,
[src]
pub fn downcast<T>(self) -> Result<Box<T, A>, Box<dyn Any + 'static, A>> where
T: Any,
[src]Attempt to downcast the box to a concrete type.
Examples
use std::any::Any; fn print_if_string(value: Box<dyn Any>) { if let Ok(string) = value.downcast::<String>() { println!("String ({}): {}", string.len(), string); } } let my_string = "Hello World".to_string(); print_if_string(Box::new(my_string)); print_if_string(Box::new(0i8));
impl<A> Box<dyn Any + 'static + Send, A> where
A: Allocator,
[src]
impl<A> Box<dyn Any + 'static + Send, A> where
A: Allocator,
[src]pub fn downcast<T>(self) -> Result<Box<T, A>, Box<dyn Any + 'static + Send, A>> where
T: Any,
[src]
pub fn downcast<T>(self) -> Result<Box<T, A>, Box<dyn Any + 'static + Send, A>> where
T: Any,
[src]Attempt to downcast the box to a concrete type.
Examples
use std::any::Any; fn print_if_string(value: Box<dyn Any + Send>) { if let Ok(string) = value.downcast::<String>() { println!("String ({}): {}", string.len(), string); } } let my_string = "Hello World".to_string(); print_if_string(Box::new(my_string)); print_if_string(Box::new(0i8));
impl<A> Box<dyn Any + 'static + Sync + Send, A> where
A: Allocator,
[src]
impl<A> Box<dyn Any + 'static + Sync + Send, A> where
A: Allocator,
[src]pub fn downcast<T>(
self
) -> Result<Box<T, A>, Box<dyn Any + 'static + Sync + Send, A>> where
T: Any,
1.51.0[src]
pub fn downcast<T>(
self
) -> Result<Box<T, A>, Box<dyn Any + 'static + Sync + Send, A>> where
T: Any,
1.51.0[src]Attempt to downcast the box to a concrete type.
Examples
use std::any::Any; fn print_if_string(value: Box<dyn Any + Send + Sync>) { if let Ok(string) = value.downcast::<String>() { println!("String ({}): {}", string.len(), string); } } let my_string = "Hello World".to_string(); print_if_string(Box::new(my_string)); print_if_string(Box::new(0i8));
Trait Implementations
impl<T, A> BorrowMut<T> for Box<T, A> where
T: ?Sized,
A: Allocator,
1.1.0[src]
impl<T, A> BorrowMut<T> for Box<T, A> where
T: ?Sized,
A: Allocator,
1.1.0[src]pub fn borrow_mut(&mut self) -> &mut T
[src]
pub fn borrow_mut(&mut self) -> &mut T
[src]Mutably borrows from an owned value. Read more
impl<T, A> Clone for Box<[T], A> where
T: Clone,
A: Allocator + Clone,
1.3.0[src]
impl<T, A> Clone for Box<[T], A> where
T: Clone,
A: Allocator + Clone,
1.3.0[src]impl<T, A> Clone for Box<T, A> where
T: Clone,
A: Allocator + Clone,
[src]
impl<T, A> Clone for Box<T, A> where
T: Clone,
A: Allocator + Clone,
[src]pub fn clone(&self) -> Box<T, A>ⓘ
[src]
pub fn clone(&self) -> Box<T, A>ⓘ
[src]Returns a new box with a clone()
of this box’s contents.
Examples
let x = Box::new(5); let y = x.clone(); // The value is the same assert_eq!(x, y); // But they are unique objects assert_ne!(&*x as *const i32, &*y as *const i32);
pub fn clone_from(&mut self, source: &Box<T, A>)
[src]
pub fn clone_from(&mut self, source: &Box<T, A>)
[src]Copies source
’s contents into self
without creating a new allocation.
Examples
let x = Box::new(5); let mut y = Box::new(10); let yp: *const i32 = &*y; y.clone_from(&x); // The value is the same assert_eq!(x, y); // And no allocation occurred assert_eq!(yp, &*y);
impl Clone for Box<str, Global>
1.3.0[src]
impl Clone for Box<str, Global>
1.3.0[src]impl Default for Box<str, Global>
1.17.0[src]
impl Default for Box<str, Global>
1.17.0[src]impl<T> Default for Box<T, Global> where
T: Default,
[src]
impl<T> Default for Box<T, Global> where
T: Default,
[src]impl<T> Default for Box<[T], Global>
[src]
impl<T> Default for Box<[T], Global>
[src]impl<I, A> DoubleEndedIterator for Box<I, A> where
I: DoubleEndedIterator + ?Sized,
A: Allocator,
[src]
impl<I, A> DoubleEndedIterator for Box<I, A> where
I: DoubleEndedIterator + ?Sized,
A: Allocator,
[src]pub fn next_back(&mut self) -> Option<<I as Iterator>::Item>
[src]
pub fn next_back(&mut self) -> Option<<I as Iterator>::Item>
[src]Removes and returns an element from the end of the iterator. Read more
pub fn nth_back(&mut self, n: usize) -> Option<<I as Iterator>::Item>
[src]
pub fn nth_back(&mut self, n: usize) -> Option<<I as Iterator>::Item>
[src]Returns the n
th element from the end of the iterator. Read more
fn advance_back_by(&mut self, n: usize) -> Result<(), usize>
[src]
fn advance_back_by(&mut self, n: usize) -> Result<(), usize>
[src]🔬 This is a nightly-only experimental API. (iter_advance_by
)
recently added
Advances the iterator from the back by n
elements. Read more
fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R where
F: FnMut(B, Self::Item) -> R,
R: Try<Output = B>,
1.27.0[src]
fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R where
F: FnMut(B, Self::Item) -> R,
R: Try<Output = B>,
1.27.0[src]This is the reverse version of Iterator::try_fold()
: it takes
elements starting from the back of the iterator. Read more
impl<I, A> ExactSizeIterator for Box<I, A> where
I: ExactSizeIterator + ?Sized,
A: Allocator,
[src]
impl<I, A> ExactSizeIterator for Box<I, A> where
I: ExactSizeIterator + ?Sized,
A: Allocator,
[src]impl Extend<Box<str, Global>> for String
1.45.0[src]
impl Extend<Box<str, Global>> for String
1.45.0[src]pub fn extend<I>(&mut self, iter: I) where
I: IntoIterator<Item = Box<str, Global>>,
[src]
pub fn extend<I>(&mut self, iter: I) where
I: IntoIterator<Item = Box<str, Global>>,
[src]Extends a collection with the contents of an iterator. Read more
fn extend_one(&mut self, item: A)
[src]
fn extend_one(&mut self, item: A)
[src]extend_one
)Extends a collection with exactly one element.
fn extend_reserve(&mut self, additional: usize)
[src]
fn extend_reserve(&mut self, additional: usize)
[src]extend_one
)Reserves capacity in a collection for the given number of additional elements. Read more
impl<Args, F, A> Fn<Args> for Box<F, A> where
F: Fn<Args> + ?Sized,
A: Allocator,
1.35.0[src]
impl<Args, F, A> Fn<Args> for Box<F, A> where
F: Fn<Args> + ?Sized,
A: Allocator,
1.35.0[src]impl<Args, F, A> FnMut<Args> for Box<F, A> where
F: FnMut<Args> + ?Sized,
A: Allocator,
1.35.0[src]
impl<Args, F, A> FnMut<Args> for Box<F, A> where
F: FnMut<Args> + ?Sized,
A: Allocator,
1.35.0[src]impl<Args, F, A> FnOnce<Args> for Box<F, A> where
F: FnOnce<Args> + ?Sized,
A: Allocator,
1.35.0[src]
impl<Args, F, A> FnOnce<Args> for Box<F, A> where
F: FnOnce<Args> + ?Sized,
A: Allocator,
1.35.0[src]impl<'_, T> From<&'_ [T]> for Box<[T], Global> where
T: Copy,
1.17.0[src]
impl<'_, T> From<&'_ [T]> for Box<[T], Global> where
T: Copy,
1.17.0[src]pub fn from(slice: &[T]) -> Box<[T], Global>ⓘ
[src]
pub fn from(slice: &[T]) -> Box<[T], Global>ⓘ
[src]Converts a &[T]
into a Box<[T]>
This conversion allocates on the heap
and performs a copy of slice
.
Examples
// create a &[u8] which will be used to create a Box<[u8]> let slice: &[u8] = &[104, 101, 108, 108, 111]; let boxed_slice: Box<[u8]> = Box::from(slice); println!("{:?}", boxed_slice);
impl<'_> From<&'_ str> for Box<str, Global>
1.17.0[src]
impl<'_> From<&'_ str> for Box<str, Global>
1.17.0[src]impl<T, const N: usize> From<[T; N]> for Box<[T], Global>
1.45.0[src]
impl<T, const N: usize> From<[T; N]> for Box<[T], Global>
1.45.0[src]impl<A> From<Box<str, A>> for Box<[u8], A> where
A: Allocator,
1.19.0[src]
impl<A> From<Box<str, A>> for Box<[u8], A> where
A: Allocator,
1.19.0[src]pub fn from(s: Box<str, A>) -> Box<[u8], A>ⓘ
[src]
pub fn from(s: Box<str, A>) -> Box<[u8], A>ⓘ
[src]Converts a Box<str>
into a Box<[u8]>
This conversion does not allocate on the heap and happens in place.
Examples
// create a Box<str> which will be used to create a Box<[u8]> let boxed: Box<str> = Box::from("hello"); let boxed_str: Box<[u8]> = Box::from(boxed); // create a &[u8] which will be used to create a Box<[u8]> let slice: &[u8] = &[104, 101, 108, 108, 111]; let boxed_slice = Box::from(slice); assert_eq!(boxed_slice, boxed_str);
impl From<Box<str, Global>> for String
1.18.0[src]
impl From<Box<str, Global>> for String
1.18.0[src]pub fn from(s: Box<str, Global>) -> String
[src]
pub fn from(s: Box<str, Global>) -> String
[src]Converts the given boxed str
slice to a String
.
It is notable that the str
slice is owned.
Examples
Basic usage:
let s1: String = String::from("hello world"); let s2: Box<str> = s1.into_boxed_str(); let s3: String = String::from(s2); assert_eq!("hello world", s3)
impl<'_, T> From<Cow<'_, [T]>> for Box<[T], Global> where
T: Copy,
1.45.0[src]
impl<'_, T> From<Cow<'_, [T]>> for Box<[T], Global> where
T: Copy,
1.45.0[src]impl<'_> From<Cow<'_, str>> for Box<str, Global>
1.45.0[src]
impl<'_> From<Cow<'_, str>> for Box<str, Global>
1.45.0[src]impl From<String> for Box<str, Global>
1.20.0[src]
impl From<String> for Box<str, Global>
1.20.0[src]impl<T> From<T> for Box<T, Global>
1.6.0[src]
impl<T> From<T> for Box<T, Global>
1.6.0[src]impl<T, A> From<Vec<T, A>> for Box<[T], A> where
A: Allocator,
1.20.0[src]
impl<T, A> From<Vec<T, A>> for Box<[T], A> where
A: Allocator,
1.20.0[src]impl FromIterator<Box<str, Global>> for String
1.45.0[src]
impl FromIterator<Box<str, Global>> for String
1.45.0[src]impl<I> FromIterator<I> for Box<[I], Global>
1.32.0[src]
impl<I> FromIterator<I> for Box<[I], Global>
1.32.0[src]impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static,
1.36.0[src]
impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static,
1.36.0[src]impl<G, R, A> Generator<R> for Box<G, A> where
A: Allocator + 'static,
G: Generator<R> + Unpin + ?Sized,
[src]
impl<G, R, A> Generator<R> for Box<G, A> where
A: Allocator + 'static,
G: Generator<R> + Unpin + ?Sized,
[src]type Yield = <G as Generator<R>>::Yield
type Yield = <G as Generator<R>>::Yield
generator_trait
)The type of value this generator yields. Read more
impl<T, A> Hasher for Box<T, A> where
T: Hasher + ?Sized,
A: Allocator,
1.22.0[src]
impl<T, A> Hasher for Box<T, A> where
T: Hasher + ?Sized,
A: Allocator,
1.22.0[src]pub fn write_u128(&mut self, i: u128)
[src]
pub fn write_u128(&mut self, i: u128)
[src]Writes a single u128
into this hasher.
pub fn write_usize(&mut self, i: usize)
[src]
pub fn write_usize(&mut self, i: usize)
[src]Writes a single usize
into this hasher.
pub fn write_i128(&mut self, i: i128)
[src]
pub fn write_i128(&mut self, i: i128)
[src]Writes a single i128
into this hasher.
pub fn write_isize(&mut self, i: isize)
[src]
pub fn write_isize(&mut self, i: isize)
[src]Writes a single isize
into this hasher.
impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator,
[src]
impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator,
[src]pub fn next(&mut self) -> Option<<I as Iterator>::Item>
[src]
pub fn next(&mut self) -> Option<<I as Iterator>::Item>
[src]Advances the iterator and returns the next value. Read more
pub fn size_hint(&self) -> (usize, Option<usize>)
[src]
pub fn size_hint(&self) -> (usize, Option<usize>)
[src]Returns the bounds on the remaining length of the iterator. Read more
pub fn nth(&mut self, n: usize) -> Option<<I as Iterator>::Item>
[src]
pub fn nth(&mut self, n: usize) -> Option<<I as Iterator>::Item>
[src]Returns the n
th element of the iterator. Read more
pub fn last(self) -> Option<<I as Iterator>::Item>
[src]
pub fn last(self) -> Option<<I as Iterator>::Item>
[src]Consumes the iterator, returning the last element. Read more
fn count(self) -> usize
[src]
fn count(self) -> usize
[src]Consumes the iterator, counting the number of iterations and returning it. Read more
fn advance_by(&mut self, n: usize) -> Result<(), usize>
[src]
fn advance_by(&mut self, n: usize) -> Result<(), usize>
[src]🔬 This is a nightly-only experimental API. (iter_advance_by
)
recently added
Advances the iterator by n
elements. Read more
fn step_by(self, step: usize) -> StepBy<Self>
1.28.0[src]
fn step_by(self, step: usize) -> StepBy<Self>
1.28.0[src]Creates an iterator starting at the same point, but stepping by the given amount at each iteration. Read more
fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter> where
U: IntoIterator<Item = Self::Item>,
[src]
fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter> where
U: IntoIterator<Item = Self::Item>,
[src]Takes two iterators and creates a new iterator over both in sequence. Read more
fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter> where
U: IntoIterator,
[src]
fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter> where
U: IntoIterator,
[src]‘Zips up’ two iterators into a single iterator of pairs. Read more
fn intersperse(self, separator: Self::Item) -> Intersperse<Self> where
Self::Item: Clone,
[src]
fn intersperse(self, separator: Self::Item) -> Intersperse<Self> where
Self::Item: Clone,
[src]🔬 This is a nightly-only experimental API. (iter_intersperse
)
recently added
Creates a new iterator which places a copy of separator
between adjacent
items of the original iterator. Read more
fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G> where
G: FnMut() -> Self::Item,
[src]
fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G> where
G: FnMut() -> Self::Item,
[src]🔬 This is a nightly-only experimental API. (iter_intersperse
)
recently added
Creates a new iterator which places an item generated by separator
between adjacent items of the original iterator. Read more
fn map<B, F>(self, f: F) -> Map<Self, F> where
F: FnMut(Self::Item) -> B,
[src]
fn map<B, F>(self, f: F) -> Map<Self, F> where
F: FnMut(Self::Item) -> B,
[src]Takes a closure and creates an iterator which calls that closure on each element. Read more
fn for_each<F>(self, f: F) where
F: FnMut(Self::Item),
1.21.0[src]
fn for_each<F>(self, f: F) where
F: FnMut(Self::Item),
1.21.0[src]Calls a closure on each element of an iterator. Read more
fn filter<P>(self, predicate: P) -> Filter<Self, P> where
P: FnMut(&Self::Item) -> bool,
[src]
fn filter<P>(self, predicate: P) -> Filter<Self, P> where
P: FnMut(&Self::Item) -> bool,
[src]Creates an iterator which uses a closure to determine if an element should be yielded. Read more
fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> where
F: FnMut(Self::Item) -> Option<B>,
[src]
fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> where
F: FnMut(Self::Item) -> Option<B>,
[src]Creates an iterator that both filters and maps. Read more
fn enumerate(self) -> Enumerate<Self>
[src]
fn enumerate(self) -> Enumerate<Self>
[src]Creates an iterator which gives the current iteration count as well as the next value. Read more
fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> where
P: FnMut(&Self::Item) -> bool,
[src]
fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> where
P: FnMut(&Self::Item) -> bool,
[src]fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> where
P: FnMut(&Self::Item) -> bool,
[src]
fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> where
P: FnMut(&Self::Item) -> bool,
[src]Creates an iterator that yields elements based on a predicate. Read more
fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P> where
P: FnMut(Self::Item) -> Option<B>,
[src]
fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P> where
P: FnMut(Self::Item) -> Option<B>,
[src]🔬 This is a nightly-only experimental API. (iter_map_while
)
recently added
Creates an iterator that both yields elements based on a predicate and maps. Read more
fn skip(self, n: usize) -> Skip<Self>
[src]
fn skip(self, n: usize) -> Skip<Self>
[src]Creates an iterator that skips the first n
elements. Read more
fn take(self, n: usize) -> Take<Self>
[src]
fn take(self, n: usize) -> Take<Self>
[src]Creates an iterator that yields the first n
elements, or fewer
if the underlying iterator ends sooner. Read more
fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F> where
F: FnMut(&mut St, Self::Item) -> Option<B>,
[src]
fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F> where
F: FnMut(&mut St, Self::Item) -> Option<B>,
[src]fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where
F: FnMut(Self::Item) -> U,
U: IntoIterator,
[src]
fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where
F: FnMut(Self::Item) -> U,
U: IntoIterator,
[src]Creates an iterator that works like map, but flattens nested structure. Read more
fn flatten(self) -> Flatten<Self> where
Self::Item: IntoIterator,
1.29.0[src]
fn flatten(self) -> Flatten<Self> where
Self::Item: IntoIterator,
1.29.0[src]Creates an iterator that flattens nested structure. Read more
fn inspect<F>(self, f: F) -> Inspect<Self, F> where
F: FnMut(&Self::Item),
[src]
fn inspect<F>(self, f: F) -> Inspect<Self, F> where
F: FnMut(&Self::Item),
[src]Does something with each element of an iterator, passing the value on. Read more
#[must_use = "if you really need to exhaust the iterator, consider `.for_each(drop)` instead"]fn collect<B>(self) -> B where
B: FromIterator<Self::Item>,
[src]
#[must_use = "if you really need to exhaust the iterator, consider `.for_each(drop)` instead"]fn collect<B>(self) -> B where
B: FromIterator<Self::Item>,
[src]Transforms an iterator into a collection. Read more
fn partition<B, F>(self, f: F) -> (B, B) where
F: FnMut(&Self::Item) -> bool,
B: Default + Extend<Self::Item>,
[src]
fn partition<B, F>(self, f: F) -> (B, B) where
F: FnMut(&Self::Item) -> bool,
B: Default + Extend<Self::Item>,
[src]Consumes an iterator, creating two collections from it. Read more
fn partition_in_place<'a, T, P>(self, predicate: P) -> usize where
Self: DoubleEndedIterator<Item = &'a mut T>,
T: 'a,
P: FnMut(&T) -> bool,
[src]
fn partition_in_place<'a, T, P>(self, predicate: P) -> usize where
Self: DoubleEndedIterator<Item = &'a mut T>,
T: 'a,
P: FnMut(&T) -> bool,
[src]🔬 This is a nightly-only experimental API. (iter_partition_in_place
)
new API
Reorders the elements of this iterator in-place according to the given predicate,
such that all those that return true
precede all those that return false
.
Returns the number of true
elements found. Read more
fn is_partitioned<P>(self, predicate: P) -> bool where
P: FnMut(Self::Item) -> bool,
[src]
fn is_partitioned<P>(self, predicate: P) -> bool where
P: FnMut(Self::Item) -> bool,
[src]🔬 This is a nightly-only experimental API. (iter_is_partitioned
)
new API
Checks if the elements of this iterator are partitioned according to the given predicate,
such that all those that return true
precede all those that return false
. Read more
fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R where
F: FnMut(B, Self::Item) -> R,
R: Try<Output = B>,
1.27.0[src]
fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R where
F: FnMut(B, Self::Item) -> R,
R: Try<Output = B>,
1.27.0[src]An iterator method that applies a function as long as it returns successfully, producing a single, final value. Read more
fn try_for_each<F, R>(&mut self, f: F) -> R where
F: FnMut(Self::Item) -> R,
R: Try<Output = ()>,
1.27.0[src]
fn try_for_each<F, R>(&mut self, f: F) -> R where
F: FnMut(Self::Item) -> R,
R: Try<Output = ()>,
1.27.0[src]An iterator method that applies a fallible function to each item in the iterator, stopping at the first error and returning that error. Read more
fn fold<B, F>(self, init: B, f: F) -> B where
F: FnMut(B, Self::Item) -> B,
[src]
fn fold<B, F>(self, init: B, f: F) -> B where
F: FnMut(B, Self::Item) -> B,
[src]Folds every element into an accumulator by applying an operation, returning the final result. Read more
fn reduce<F>(self, f: F) -> Option<Self::Item> where
F: FnMut(Self::Item, Self::Item) -> Self::Item,
1.51.0[src]
fn reduce<F>(self, f: F) -> Option<Self::Item> where
F: FnMut(Self::Item, Self::Item) -> Self::Item,
1.51.0[src]Reduces the elements to a single one, by repeatedly applying a reducing operation. Read more
fn all<F>(&mut self, f: F) -> bool where
F: FnMut(Self::Item) -> bool,
[src]
fn all<F>(&mut self, f: F) -> bool where
F: FnMut(Self::Item) -> bool,
[src]Tests if every element of the iterator matches a predicate. Read more
fn any<F>(&mut self, f: F) -> bool where
F: FnMut(Self::Item) -> bool,
[src]
fn any<F>(&mut self, f: F) -> bool where
F: FnMut(Self::Item) -> bool,
[src]Tests if any element of the iterator matches a predicate. Read more
fn find<P>(&mut self, predicate: P) -> Option<Self::Item> where
P: FnMut(&Self::Item) -> bool,
[src]
fn find<P>(&mut self, predicate: P) -> Option<Self::Item> where
P: FnMut(&Self::Item) -> bool,
[src]Searches for an element of an iterator that satisfies a predicate. Read more
fn find_map<B, F>(&mut self, f: F) -> Option<B> where
F: FnMut(Self::Item) -> Option<B>,
1.30.0[src]
fn find_map<B, F>(&mut self, f: F) -> Option<B> where
F: FnMut(Self::Item) -> Option<B>,
1.30.0[src]Applies function to the elements of iterator and returns the first non-none result. Read more
fn try_find<F, R, E>(&mut self, f: F) -> Result<Option<Self::Item>, E> where
F: FnMut(&Self::Item) -> R,
R: Try<Output = bool, Residual = Result<Infallible, E>> + Try,
[src]
fn try_find<F, R, E>(&mut self, f: F) -> Result<Option<Self::Item>, E> where
F: FnMut(&Self::Item) -> R,
R: Try<Output = bool, Residual = Result<Infallible, E>> + Try,
[src]🔬 This is a nightly-only experimental API. (try_find
)
new API
Applies function to the elements of iterator and returns the first true result or the first error. Read more
fn position<P>(&mut self, predicate: P) -> Option<usize> where
P: FnMut(Self::Item) -> bool,
[src]
fn position<P>(&mut self, predicate: P) -> Option<usize> where
P: FnMut(Self::Item) -> bool,
[src]Searches for an element in an iterator, returning its index. Read more
fn rposition<P>(&mut self, predicate: P) -> Option<usize> where
Self: ExactSizeIterator + DoubleEndedIterator,
P: FnMut(Self::Item) -> bool,
[src]
fn rposition<P>(&mut self, predicate: P) -> Option<usize> where
Self: ExactSizeIterator + DoubleEndedIterator,
P: FnMut(Self::Item) -> bool,
[src]Searches for an element in an iterator from the right, returning its index. Read more
fn max(self) -> Option<Self::Item> where
Self::Item: Ord,
[src]
fn max(self) -> Option<Self::Item> where
Self::Item: Ord,
[src]Returns the maximum element of an iterator. Read more
fn min(self) -> Option<Self::Item> where
Self::Item: Ord,
[src]
fn min(self) -> Option<Self::Item> where
Self::Item: Ord,
[src]Returns the minimum element of an iterator. Read more
fn max_by_key<B, F>(self, f: F) -> Option<Self::Item> where
F: FnMut(&Self::Item) -> B,
B: Ord,
1.6.0[src]
fn max_by_key<B, F>(self, f: F) -> Option<Self::Item> where
F: FnMut(&Self::Item) -> B,
B: Ord,
1.6.0[src]Returns the element that gives the maximum value from the specified function. Read more
fn max_by<F>(self, compare: F) -> Option<Self::Item> where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
1.15.0[src]
fn max_by<F>(self, compare: F) -> Option<Self::Item> where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
1.15.0[src]Returns the element that gives the maximum value with respect to the specified comparison function. Read more
fn min_by_key<B, F>(self, f: F) -> Option<Self::Item> where
F: FnMut(&Self::Item) -> B,
B: Ord,
1.6.0[src]
fn min_by_key<B, F>(self, f: F) -> Option<Self::Item> where
F: FnMut(&Self::Item) -> B,
B: Ord,
1.6.0[src]Returns the element that gives the minimum value from the specified function. Read more
fn min_by<F>(self, compare: F) -> Option<Self::Item> where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
1.15.0[src]
fn min_by<F>(self, compare: F) -> Option<Self::Item> where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
1.15.0[src]Returns the element that gives the minimum value with respect to the specified comparison function. Read more
fn rev(self) -> Rev<Self> where
Self: DoubleEndedIterator,
[src]
fn rev(self) -> Rev<Self> where
Self: DoubleEndedIterator,
[src]Reverses an iterator’s direction. Read more
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
Self: Iterator<Item = (A, B)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
[src]
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
Self: Iterator<Item = (A, B)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
[src]Converts an iterator of pairs into a pair of containers. Read more
fn copied<'a, T>(self) -> Copied<Self> where
Self: Iterator<Item = &'a T>,
T: 'a + Copy,
1.36.0[src]
fn copied<'a, T>(self) -> Copied<Self> where
Self: Iterator<Item = &'a T>,
T: 'a + Copy,
1.36.0[src]Creates an iterator which copies all of its elements. Read more
fn sum<S>(self) -> S where
S: Sum<Self::Item>,
1.11.0[src]
fn sum<S>(self) -> S where
S: Sum<Self::Item>,
1.11.0[src]Sums the elements of an iterator. Read more
fn product<P>(self) -> P where
P: Product<Self::Item>,
1.11.0[src]
fn product<P>(self) -> P where
P: Product<Self::Item>,
1.11.0[src]Iterates over the entire iterator, multiplying all the elements Read more
fn cmp<I>(self, other: I) -> Ordering where
I: IntoIterator<Item = Self::Item>,
Self::Item: Ord,
1.5.0[src]
fn cmp<I>(self, other: I) -> Ordering where
I: IntoIterator<Item = Self::Item>,
Self::Item: Ord,
1.5.0[src]Lexicographically compares the elements of this Iterator
with those
of another. Read more
fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering where
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
[src]
fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering where
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
[src]iter_order_by
)Lexicographically compares the elements of this Iterator
with those
of another with respect to the specified comparison function. Read more
fn partial_cmp<I>(self, other: I) -> Option<Ordering> where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]
fn partial_cmp<I>(self, other: I) -> Option<Ordering> where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]Lexicographically compares the elements of this Iterator
with those
of another. Read more
fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering> where
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
[src]
fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering> where
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
[src]iter_order_by
)Lexicographically compares the elements of this Iterator
with those
of another with respect to the specified comparison function. Read more
fn eq<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
1.5.0[src]
fn eq<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
1.5.0[src]fn eq_by<I, F>(self, other: I, eq: F) -> bool where
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
[src]
fn eq_by<I, F>(self, other: I, eq: F) -> bool where
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
[src]iter_order_by
)fn ne<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
1.5.0[src]
fn ne<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
1.5.0[src]fn lt<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]
fn lt<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]Determines if the elements of this Iterator
are lexicographically
less than those of another. Read more
fn le<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]
fn le<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]Determines if the elements of this Iterator
are lexicographically
less or equal to those of another. Read more
fn gt<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]
fn gt<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]Determines if the elements of this Iterator
are lexicographically
greater than those of another. Read more
fn ge<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]
fn ge<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]Determines if the elements of this Iterator
are lexicographically
greater than or equal to those of another. Read more
fn is_sorted(self) -> bool where
Self::Item: PartialOrd<Self::Item>,
[src]
fn is_sorted(self) -> bool where
Self::Item: PartialOrd<Self::Item>,
[src]🔬 This is a nightly-only experimental API. (is_sorted
)
new API
Checks if the elements of this iterator are sorted. Read more
fn is_sorted_by<F>(self, compare: F) -> bool where
F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,
[src]
fn is_sorted_by<F>(self, compare: F) -> bool where
F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,
[src]🔬 This is a nightly-only experimental API. (is_sorted
)
new API
Checks if the elements of this iterator are sorted using the given comparator function. Read more
fn is_sorted_by_key<F, K>(self, f: F) -> bool where
F: FnMut(Self::Item) -> K,
K: PartialOrd<K>,
[src]
fn is_sorted_by_key<F, K>(self, f: F) -> bool where
F: FnMut(Self::Item) -> K,
K: PartialOrd<K>,
[src]🔬 This is a nightly-only experimental API. (is_sorted
)
new API
Checks if the elements of this iterator are sorted using the given key extraction function. Read more
impl<T> NestedDecode for Box<T, Global> where
T: NestedDecode,
impl<T> NestedDecode for Box<T, Global> where
T: NestedDecode,
pub fn dep_decode<I>(input: &mut I) -> Result<Box<T, Global>, DecodeError> where
I: NestedDecodeInput,
pub fn dep_decode<I>(input: &mut I) -> Result<Box<T, Global>, DecodeError> where
I: NestedDecodeInput,
Attempt to deserialise the value from input, using the format of an object nested inside another structure. In case of success returns the deserialized value and the number of bytes consumed during the operation. Read more
pub fn dep_decode_or_exit<I, ExitCtx>(
input: &mut I,
c: ExitCtx,
exit: fn(ExitCtx, DecodeError) -> !
) -> Box<T, Global>ⓘ where
ExitCtx: Clone,
I: NestedDecodeInput,
pub fn dep_decode_or_exit<I, ExitCtx>(
input: &mut I,
c: ExitCtx,
exit: fn(ExitCtx, DecodeError) -> !
) -> Box<T, Global>ⓘ where
ExitCtx: Clone,
I: NestedDecodeInput,
Version of top_decode
that exits quickly in case of error.
Its purpose is to create smaller implementations
in cases where the application is supposed to exit directly on decode error. Read more
impl NestedDecode for Box<str, Global>
impl NestedDecode for Box<str, Global>
pub fn dep_decode<I>(input: &mut I) -> Result<Box<str, Global>, DecodeError> where
I: NestedDecodeInput,
pub fn dep_decode<I>(input: &mut I) -> Result<Box<str, Global>, DecodeError> where
I: NestedDecodeInput,
Attempt to deserialise the value from input, using the format of an object nested inside another structure. In case of success returns the deserialized value and the number of bytes consumed during the operation. Read more
pub fn dep_decode_or_exit<I, ExitCtx>(
input: &mut I,
c: ExitCtx,
exit: fn(ExitCtx, DecodeError) -> !
) -> Box<str, Global>ⓘ where
ExitCtx: Clone,
I: NestedDecodeInput,
pub fn dep_decode_or_exit<I, ExitCtx>(
input: &mut I,
c: ExitCtx,
exit: fn(ExitCtx, DecodeError) -> !
) -> Box<str, Global>ⓘ where
ExitCtx: Clone,
I: NestedDecodeInput,
Version of top_decode
that exits quickly in case of error.
Its purpose is to create smaller implementations
in cases where the application is supposed to exit directly on decode error. Read more
impl<T> NestedEncode for Box<T, Global> where
T: NestedEncode,
impl<T> NestedEncode for Box<T, Global> where
T: NestedEncode,
pub fn dep_encode<O>(&self, dest: &mut O) -> Result<(), EncodeError> where
O: NestedEncodeOutput,
pub fn dep_encode<O>(&self, dest: &mut O) -> Result<(), EncodeError> where
O: NestedEncodeOutput,
NestedEncode to output, using the format of an object nested inside another structure. Does not provide compact version. Read more
pub fn dep_encode_or_exit<O, ExitCtx>(
&self,
dest: &mut O,
c: ExitCtx,
exit: fn(ExitCtx, EncodeError) -> !
) where
O: NestedEncodeOutput,
ExitCtx: Clone,
pub fn dep_encode_or_exit<O, ExitCtx>(
&self,
dest: &mut O,
c: ExitCtx,
exit: fn(ExitCtx, EncodeError) -> !
) where
O: NestedEncodeOutput,
ExitCtx: Clone,
Version of top_decode
that exits quickly in case of error.
Its purpose is to create smaller implementations
in cases where the application is supposed to exit directly on decode error. Read more
impl NestedEncode for Box<str, Global>
impl NestedEncode for Box<str, Global>
pub fn dep_encode<O>(&self, dest: &mut O) -> Result<(), EncodeError> where
O: NestedEncodeOutput,
pub fn dep_encode<O>(&self, dest: &mut O) -> Result<(), EncodeError> where
O: NestedEncodeOutput,
NestedEncode to output, using the format of an object nested inside another structure. Does not provide compact version. Read more
pub fn dep_encode_or_exit<O, ExitCtx>(
&self,
dest: &mut O,
c: ExitCtx,
exit: fn(ExitCtx, EncodeError) -> !
) where
O: NestedEncodeOutput,
ExitCtx: Clone,
pub fn dep_encode_or_exit<O, ExitCtx>(
&self,
dest: &mut O,
c: ExitCtx,
exit: fn(ExitCtx, EncodeError) -> !
) where
O: NestedEncodeOutput,
ExitCtx: Clone,
Version of top_decode
that exits quickly in case of error.
Its purpose is to create smaller implementations
in cases where the application is supposed to exit directly on decode error. Read more
impl<T> NestedEncode for Box<[T], Global> where
T: NestedEncode,
impl<T> NestedEncode for Box<[T], Global> where
T: NestedEncode,
pub fn dep_encode<O>(&self, dest: &mut O) -> Result<(), EncodeError> where
O: NestedEncodeOutput,
pub fn dep_encode<O>(&self, dest: &mut O) -> Result<(), EncodeError> where
O: NestedEncodeOutput,
NestedEncode to output, using the format of an object nested inside another structure. Does not provide compact version. Read more
pub fn dep_encode_or_exit<O, ExitCtx>(
&self,
dest: &mut O,
c: ExitCtx,
exit: fn(ExitCtx, EncodeError) -> !
) where
O: NestedEncodeOutput,
ExitCtx: Clone,
pub fn dep_encode_or_exit<O, ExitCtx>(
&self,
dest: &mut O,
c: ExitCtx,
exit: fn(ExitCtx, EncodeError) -> !
) where
O: NestedEncodeOutput,
ExitCtx: Clone,
Version of top_decode
that exits quickly in case of error.
Its purpose is to create smaller implementations
in cases where the application is supposed to exit directly on decode error. Read more
impl<T, A> Ord for Box<T, A> where
T: Ord + ?Sized,
A: Allocator,
[src]
impl<T, A> Ord for Box<T, A> where
T: Ord + ?Sized,
A: Allocator,
[src]impl<T, A> PartialOrd<Box<T, A>> for Box<T, A> where
T: PartialOrd<T> + ?Sized,
A: Allocator,
[src]
impl<T, A> PartialOrd<Box<T, A>> for Box<T, A> where
T: PartialOrd<T> + ?Sized,
A: Allocator,
[src]pub fn partial_cmp(&self, other: &Box<T, A>) -> Option<Ordering>
[src]
pub fn partial_cmp(&self, other: &Box<T, A>) -> Option<Ordering>
[src]This method returns an ordering between self
and other
values if one exists. Read more
pub fn lt(&self, other: &Box<T, A>) -> bool
[src]
pub fn lt(&self, other: &Box<T, A>) -> bool
[src]This method tests less than (for self
and other
) and is used by the <
operator. Read more
pub fn le(&self, other: &Box<T, A>) -> bool
[src]
pub fn le(&self, other: &Box<T, A>) -> bool
[src]This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
impl<S> Stream for Box<S, Global> where
S: Stream + Unpin + ?Sized,
[src]
impl<S> Stream for Box<S, Global> where
S: Stream + Unpin + ?Sized,
[src]type Item = <S as Stream>::Item
type Item = <S as Stream>::Item
async_stream
)The type of items yielded by the stream.
pub fn poll_next(
self: Pin<&mut Box<S, Global>>,
cx: &mut Context<'_>
) -> Poll<Option<<Box<S, Global> as Stream>::Item>>
[src]
pub fn poll_next(
self: Pin<&mut Box<S, Global>>,
cx: &mut Context<'_>
) -> Poll<Option<<Box<S, Global> as Stream>::Item>>
[src]async_stream
)Attempt to pull out the next value of this stream, registering the
current task for wakeup if the value is not yet available, and returning
None
if the stream is exhausted. Read more
impl<T> TopDecode for Box<T, Global> where
T: TopDecode,
impl<T> TopDecode for Box<T, Global> where
T: TopDecode,
pub fn top_decode<I>(input: I) -> Result<Box<T, Global>, DecodeError> where
I: TopDecodeInput,
pub fn top_decode<I>(input: I) -> Result<Box<T, Global>, DecodeError> where
I: TopDecodeInput,
Attempt to deserialize the value from input.
pub fn top_decode_or_exit<I, ExitCtx>(
input: I,
c: ExitCtx,
exit: fn(ExitCtx, DecodeError) -> !
) -> Box<T, Global>ⓘ where
ExitCtx: Clone,
I: TopDecodeInput,
pub fn top_decode_or_exit<I, ExitCtx>(
input: I,
c: ExitCtx,
exit: fn(ExitCtx, DecodeError) -> !
) -> Box<T, Global>ⓘ where
ExitCtx: Clone,
I: TopDecodeInput,
Version of top_decode
that exits quickly in case of error.
Its purpose is to create smaller implementations
in cases where the application is supposed to exit directly on decode error. Read more
impl<T> TopDecode for Box<[T], Global> where
T: NestedDecode,
impl<T> TopDecode for Box<[T], Global> where
T: NestedDecode,
pub fn top_decode_or_exit<I, ExitCtx>(
input: I,
c: ExitCtx,
exit: fn(ExitCtx, DecodeError) -> !
) -> Box<[T], Global>ⓘ where
ExitCtx: Clone,
I: TopDecodeInput,
pub fn top_decode_or_exit<I, ExitCtx>(
input: I,
c: ExitCtx,
exit: fn(ExitCtx, DecodeError) -> !
) -> Box<[T], Global>ⓘ where
ExitCtx: Clone,
I: TopDecodeInput,
Quick exit for any of the contained types
pub fn top_decode<I>(input: I) -> Result<Box<[T], Global>, DecodeError> where
I: TopDecodeInput,
pub fn top_decode<I>(input: I) -> Result<Box<[T], Global>, DecodeError> where
I: TopDecodeInput,
Attempt to deserialize the value from input.
impl TopDecode for Box<str, Global>
impl TopDecode for Box<str, Global>
pub fn top_decode<I>(input: I) -> Result<Box<str, Global>, DecodeError> where
I: TopDecodeInput,
pub fn top_decode<I>(input: I) -> Result<Box<str, Global>, DecodeError> where
I: TopDecodeInput,
Attempt to deserialize the value from input.
pub fn top_decode_or_exit<I, ExitCtx>(
input: I,
c: ExitCtx,
exit: fn(ExitCtx, DecodeError) -> !
) -> Box<str, Global>ⓘ where
ExitCtx: Clone,
I: TopDecodeInput,
pub fn top_decode_or_exit<I, ExitCtx>(
input: I,
c: ExitCtx,
exit: fn(ExitCtx, DecodeError) -> !
) -> Box<str, Global>ⓘ where
ExitCtx: Clone,
I: TopDecodeInput,
Version of top_decode
that exits quickly in case of error.
Its purpose is to create smaller implementations
in cases where the application is supposed to exit directly on decode error. Read more
impl TopDecodeInput for Box<[u8], Global>
impl TopDecodeInput for Box<[u8], Global>
pub fn byte_len(&self) -> usize
pub fn byte_len(&self) -> usize
Length of the underlying data, in bytes.
pub fn into_boxed_slice_u8(self) -> Box<[u8], Global>ⓘ
pub fn into_boxed_slice_u8(self) -> Box<[u8], Global>ⓘ
Provides the underlying data as an owned byte slice box. Consumes the input object in the process. Read more
impl<T> TopEncode for Box<[T], Global> where
T: NestedEncode,
impl<T> TopEncode for Box<[T], Global> where
T: NestedEncode,
pub fn top_encode<O>(&self, output: O) -> Result<(), EncodeError> where
O: TopEncodeOutput,
pub fn top_encode<O>(&self, output: O) -> Result<(), EncodeError> where
O: TopEncodeOutput,
Attempt to serialize the value to ouput.
pub fn top_encode_or_exit<O, ExitCtx>(
&self,
output: O,
c: ExitCtx,
exit: fn(ExitCtx, EncodeError) -> !
) where
O: TopEncodeOutput,
ExitCtx: Clone,
pub fn top_encode_or_exit<O, ExitCtx>(
&self,
output: O,
c: ExitCtx,
exit: fn(ExitCtx, EncodeError) -> !
) where
O: TopEncodeOutput,
ExitCtx: Clone,
Version of top_decode
that exits quickly in case of error.
Its purpose is to create smaller bytecode implementations
in cases where the application is supposed to exit directly on decode error. Read more
impl<T> TopEncode for Box<T, Global> where
T: TopEncode,
impl<T> TopEncode for Box<T, Global> where
T: TopEncode,
pub fn top_encode<O>(&self, output: O) -> Result<(), EncodeError> where
O: TopEncodeOutput,
pub fn top_encode<O>(&self, output: O) -> Result<(), EncodeError> where
O: TopEncodeOutput,
Attempt to serialize the value to ouput.
pub fn top_encode_or_exit<O, ExitCtx>(
&self,
output: O,
c: ExitCtx,
exit: fn(ExitCtx, EncodeError) -> !
) where
O: TopEncodeOutput,
ExitCtx: Clone,
pub fn top_encode_or_exit<O, ExitCtx>(
&self,
output: O,
c: ExitCtx,
exit: fn(ExitCtx, EncodeError) -> !
) where
O: TopEncodeOutput,
ExitCtx: Clone,
Version of top_decode
that exits quickly in case of error.
Its purpose is to create smaller bytecode implementations
in cases where the application is supposed to exit directly on decode error. Read more
impl TopEncode for Box<str, Global>
impl TopEncode for Box<str, Global>
pub fn top_encode<O>(&self, output: O) -> Result<(), EncodeError> where
O: TopEncodeOutput,
pub fn top_encode<O>(&self, output: O) -> Result<(), EncodeError> where
O: TopEncodeOutput,
Attempt to serialize the value to ouput.
pub fn top_encode_or_exit<O, ExitCtx>(
&self,
output: O,
c: ExitCtx,
exit: fn(ExitCtx, EncodeError) -> !
) where
O: TopEncodeOutput,
ExitCtx: Clone,
pub fn top_encode_or_exit<O, ExitCtx>(
&self,
output: O,
c: ExitCtx,
exit: fn(ExitCtx, EncodeError) -> !
) where
O: TopEncodeOutput,
ExitCtx: Clone,
Version of top_decode
that exits quickly in case of error.
Its purpose is to create smaller bytecode implementations
in cases where the application is supposed to exit directly on decode error. Read more
impl<T> TypeAbi for Box<T, Global> where
T: TypeAbi,
[src]
impl<T> TypeAbi for Box<T, Global> where
T: TypeAbi,
[src]pub fn type_name() -> String
[src]
pub fn provide_type_descriptions<TDC>(accumulator: &mut TDC) where
TDC: TypeDescriptionContainer,
[src]
pub fn provide_type_descriptions<TDC>(accumulator: &mut TDC) where
TDC: TypeDescriptionContainer,
[src]A type can provide more than its own description. For instance, a struct can also provide the descriptions of the type of its fields. TypeAbi doesn’t care for the exact accumulator type, which is abstracted by the TypeDescriptionContainer trait. Read more
impl<T> TypeAbi for Box<[T], Global> where
T: TypeAbi,
[src]
impl<T> TypeAbi for Box<[T], Global> where
T: TypeAbi,
[src]pub fn type_name() -> String
[src]
fn provide_type_descriptions<TDC>(accumulator: &mut TDC) where
TDC: TypeDescriptionContainer,
[src]
fn provide_type_descriptions<TDC>(accumulator: &mut TDC) where
TDC: TypeDescriptionContainer,
[src]A type can provide more than its own description. For instance, a struct can also provide the descriptions of the type of its fields. TypeAbi doesn’t care for the exact accumulator type, which is abstracted by the TypeDescriptionContainer trait. Read more
impl TypeAbi for Box<str, Global>
[src]
impl TypeAbi for Box<str, Global>
[src]pub fn type_name() -> String
[src]
fn provide_type_descriptions<TDC>(accumulator: &mut TDC) where
TDC: TypeDescriptionContainer,
[src]
fn provide_type_descriptions<TDC>(accumulator: &mut TDC) where
TDC: TypeDescriptionContainer,
[src]A type can provide more than its own description. For instance, a struct can also provide the descriptions of the type of its fields. TypeAbi doesn’t care for the exact accumulator type, which is abstracted by the TypeDescriptionContainer trait. Read more
impl<T, U, A> CoerceUnsized<Box<U, A>> for Box<T, A> where
T: Unsize<U> + ?Sized,
A: Allocator,
U: ?Sized,
[src]
T: Unsize<U> + ?Sized,
A: Allocator,
U: ?Sized,
impl<T, U> DispatchFromDyn<Box<U, Global>> for Box<T, Global> where
T: Unsize<U> + ?Sized,
U: ?Sized,
[src]
T: Unsize<U> + ?Sized,
U: ?Sized,
impl<T, A> Eq for Box<T, A> where
T: Eq + ?Sized,
A: Allocator,
[src]
T: Eq + ?Sized,
A: Allocator,
impl<I, A> FusedIterator for Box<I, A> where
I: FusedIterator + ?Sized,
A: Allocator,
1.26.0[src]
I: FusedIterator + ?Sized,
A: Allocator,
impl<T, A> Unpin for Box<T, A> where
T: ?Sized,
A: Allocator + 'static,
1.33.0[src]
T: ?Sized,
A: Allocator + 'static,
Auto Trait Implementations
impl<T: ?Sized, A> Send for Box<T, A> where
A: Send,
T: Send,
A: Send,
T: Send,
impl<T: ?Sized, A> Sync for Box<T, A> where
A: Sync,
T: Sync,
A: Sync,
T: Sync,
Blanket Implementations
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]pub fn borrow_mut(&mut self) -> &mut T
[src]
pub fn borrow_mut(&mut self) -> &mut T
[src]Mutably borrows from an owned value. Read more
impl<T> CallHasher for T where
T: Hash,
impl<T> CallHasher for T where
T: Hash,
impl<T> ContractCallArg for T where
T: TopEncode,
[src]
impl<T> ContractCallArg for T where
T: TopEncode,
[src]pub fn push_async_arg(&self, serializer: &mut ArgBuffer) -> Result<(), SCError>
[src]
impl<T> DynArg for T where
T: TopDecode,
[src]
impl<T> DynArg for T where
T: TopDecode,
[src]pub fn dyn_load<I, D>(loader: &mut D, arg_id: ArgId) -> T where
I: TopDecodeInput,
D: DynArgInput<I>,
[src]
I: TopDecodeInput,
D: DynArgInput<I>,
impl<T> EndpointResult for T where
T: TopEncode,
[src]
impl<T> EndpointResult for T where
T: TopEncode,
[src]impl<F> IntoFuture for F where
F: Future,
[src]
impl<F> IntoFuture for F where
F: Future,
[src]type Output = <F as Future>::Output
type Output = <F as Future>::Output
into_future
)The output that the future will produce on completion.
type Future = F
type Future = F
into_future
)Which kind of future are we turning this into?
pub fn into_future(self) -> <F as IntoFuture>::Future
[src]
pub fn into_future(self) -> <F as IntoFuture>::Future
[src]into_future
)Creates a future from a value.
impl<I> IntoIterator for I where
I: Iterator,
[src]
impl<I> IntoIterator for I where
I: Iterator,
[src]impl<'a, F> Pattern<'a> for F where
F: FnMut(char) -> bool,
[src]
impl<'a, F> Pattern<'a> for F where
F: FnMut(char) -> bool,
[src]type Searcher = CharPredicateSearcher<'a, F>
type Searcher = CharPredicateSearcher<'a, F>
🔬 This is a nightly-only experimental API. (pattern
)
API not fully fleshed out and ready to be stabilized
Associated searcher for this pattern
pub fn into_searcher(self, haystack: &'a str) -> CharPredicateSearcher<'a, F>
[src]
pub fn into_searcher(self, haystack: &'a str) -> CharPredicateSearcher<'a, F>
[src]🔬 This is a nightly-only experimental API. (pattern
)
API not fully fleshed out and ready to be stabilized
Constructs the associated searcher from
self
and the haystack
to search in. Read more
pub fn is_contained_in(self, haystack: &'a str) -> bool
[src]
pub fn is_contained_in(self, haystack: &'a str) -> bool
[src]🔬 This is a nightly-only experimental API. (pattern
)
API not fully fleshed out and ready to be stabilized
Checks whether the pattern matches anywhere in the haystack
pub fn is_prefix_of(self, haystack: &'a str) -> bool
[src]
pub fn is_prefix_of(self, haystack: &'a str) -> bool
[src]🔬 This is a nightly-only experimental API. (pattern
)
API not fully fleshed out and ready to be stabilized
Checks whether the pattern matches at the front of the haystack
pub fn strip_prefix_of(self, haystack: &'a str) -> Option<&'a str>
[src]
pub fn strip_prefix_of(self, haystack: &'a str) -> Option<&'a str>
[src]🔬 This is a nightly-only experimental API. (pattern
)
API not fully fleshed out and ready to be stabilized
Removes the pattern from the front of haystack, if it matches.
pub fn is_suffix_of(self, haystack: &'a str) -> bool where
CharPredicateSearcher<'a, F>: ReverseSearcher<'a>,
[src]
pub fn is_suffix_of(self, haystack: &'a str) -> bool where
CharPredicateSearcher<'a, F>: ReverseSearcher<'a>,
[src]🔬 This is a nightly-only experimental API. (pattern
)
API not fully fleshed out and ready to be stabilized
Checks whether the pattern matches at the back of the haystack
pub fn strip_suffix_of(self, haystack: &'a str) -> Option<&'a str> where
CharPredicateSearcher<'a, F>: ReverseSearcher<'a>,
[src]
pub fn strip_suffix_of(self, haystack: &'a str) -> Option<&'a str> where
CharPredicateSearcher<'a, F>: ReverseSearcher<'a>,
[src]🔬 This is a nightly-only experimental API. (pattern
)
API not fully fleshed out and ready to be stabilized
Removes the pattern from the back of haystack, if it matches.
impl<T> ToOwned for T where
T: Clone,
[src]
impl<T> ToOwned for T where
T: Clone,
[src]type Owned = T
type Owned = T
The resulting type after obtaining ownership.
pub fn to_owned(&self) -> T
[src]
pub fn to_owned(&self) -> T
[src]Creates owned data from borrowed data, usually by cloning. Read more
pub fn clone_into(&self, target: &mut T)
[src]
pub fn clone_into(&self, target: &mut T)
[src]🔬 This is a nightly-only experimental API. (toowned_clone_into
)
recently added
Uses borrowed data to replace owned data, usually by cloning. Read more