Type Alias freya_renderer::WindowBuilderHook
source · pub type WindowBuilderHook = Box<dyn Fn(WindowAttributes) -> WindowAttributes>;
Aliased Type§
struct WindowBuilderHook(/* private fields */);
Implementations
source§impl<T> Box<T>
impl<T> Box<T>
1.0.0 · sourcepub fn new(x: T) -> Box<T>
pub fn new(x: T) -> Box<T>
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);
sourcepub fn new_uninit() -> Box<MaybeUninit<T>>
🔬This is a nightly-only experimental API. (new_uninit
)
pub fn new_uninit() -> Box<MaybeUninit<T>>
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)
sourcepub fn new_zeroed() -> Box<MaybeUninit<T>>
🔬This is a nightly-only experimental API. (new_uninit
)
pub fn new_zeroed() -> Box<MaybeUninit<T>>
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)
1.33.0 · sourcepub fn pin(x: T) -> Pin<Box<T>>
pub fn pin(x: T) -> Pin<Box<T>>
Constructs a new Pin<Box<T>>
. If T
does not implement Unpin
, then
x
will be pinned in memory and unable to be moved.
Constructing and pinning of the Box
can also be done in two steps: Box::pin(x)
does the same as Box::into_pin(Box::new(x))
. Consider using
into_pin
if you already have a Box<T>
, or if you want to
construct a (pinned) Box
in a different way than with Box::new
.
sourcepub fn try_new(x: T) -> Result<Box<T>, AllocError>
🔬This is a nightly-only experimental API. (allocator_api
)
pub fn try_new(x: T) -> Result<Box<T>, AllocError>
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)?;
sourcepub fn try_new_uninit() -> Result<Box<MaybeUninit<T>>, AllocError>
🔬This is a nightly-only experimental API. (allocator_api
)
pub fn try_new_uninit() -> Result<Box<MaybeUninit<T>>, AllocError>
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);
sourcepub fn try_new_zeroed() -> Result<Box<MaybeUninit<T>>, AllocError>
🔬This is a nightly-only experimental API. (allocator_api
)
pub fn try_new_zeroed() -> Result<Box<MaybeUninit<T>>, AllocError>
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);
source§impl<T> Box<T>where
T: ?Sized,
impl<T> Box<T>where
T: ?Sized,
1.4.0 · sourcepub unsafe fn from_raw(raw: *mut T) -> Box<T>
pub unsafe fn from_raw(raw: *mut T) -> Box<T>
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);
}
source§impl<T, A> Box<T, A>where
A: Allocator,
impl<T, A> Box<T, A>where
A: Allocator,
sourcepub fn new_in(x: T, alloc: A) -> Box<T, A>where
A: Allocator,
🔬This is a nightly-only experimental API. (allocator_api
)
pub fn new_in(x: T, alloc: A) -> Box<T, A>where
A: Allocator,
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);
sourcepub fn try_new_in(x: T, alloc: A) -> Result<Box<T, A>, AllocError>where
A: Allocator,
🔬This is a nightly-only experimental API. (allocator_api
)
pub fn try_new_in(x: T, alloc: A) -> Result<Box<T, A>, AllocError>where
A: Allocator,
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)?;
sourcepub fn new_uninit_in(alloc: A) -> Box<MaybeUninit<T>, A>where
A: Allocator,
🔬This is a nightly-only experimental API. (allocator_api
)
pub fn new_uninit_in(alloc: A) -> Box<MaybeUninit<T>, A>where
A: Allocator,
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)
sourcepub fn try_new_uninit_in(alloc: A) -> Result<Box<MaybeUninit<T>, A>, AllocError>where
A: Allocator,
🔬This is a nightly-only experimental API. (allocator_api
)
pub fn try_new_uninit_in(alloc: A) -> Result<Box<MaybeUninit<T>, A>, AllocError>where
A: Allocator,
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);
sourcepub fn new_zeroed_in(alloc: A) -> Box<MaybeUninit<T>, A>where
A: Allocator,
🔬This is a nightly-only experimental API. (allocator_api
)
pub fn new_zeroed_in(alloc: A) -> Box<MaybeUninit<T>, A>where
A: Allocator,
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)
sourcepub fn try_new_zeroed_in(alloc: A) -> Result<Box<MaybeUninit<T>, A>, AllocError>where
A: Allocator,
🔬This is a nightly-only experimental API. (allocator_api
)
pub fn try_new_zeroed_in(alloc: A) -> Result<Box<MaybeUninit<T>, A>, AllocError>where
A: Allocator,
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);
sourcepub fn pin_in(x: T, alloc: A) -> Pin<Box<T, A>>where
A: 'static + Allocator,
🔬This is a nightly-only experimental API. (allocator_api
)
pub fn pin_in(x: T, alloc: A) -> Pin<Box<T, A>>where
A: 'static + Allocator,
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.
Constructing and pinning of the Box
can also be done in two steps: Box::pin_in(x, alloc)
does the same as Box::into_pin(Box::new_in(x, alloc))
. Consider using
into_pin
if you already have a Box<T, A>
, or if you want to
construct a (pinned) Box
in a different way than with Box::new_in
.
sourcepub fn into_boxed_slice(boxed: Box<T, A>) -> Box<[T], A>
🔬This is a nightly-only experimental API. (box_into_boxed_slice
)
pub fn into_boxed_slice(boxed: Box<T, A>) -> Box<[T], A>
box_into_boxed_slice
)Converts a Box<T>
into a Box<[T]>
This conversion does not allocate on the heap and happens in place.
sourcepub fn into_inner(boxed: Box<T, A>) -> T
🔬This is a nightly-only experimental API. (box_into_inner
)
pub fn into_inner(boxed: Box<T, A>) -> T
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);
source§impl<T, A> Box<T, A>
impl<T, A> Box<T, A>
const: unstable · sourcepub unsafe fn from_raw_in(raw: *mut T, alloc: A) -> Box<T, A>
🔬This is a nightly-only experimental API. (allocator_api
)
pub unsafe fn from_raw_in(raw: *mut T, alloc: A) -> Box<T, A>
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);
}
1.4.0 · sourcepub fn into_raw(b: Box<T, A>) -> *mut T
pub fn into_raw(b: Box<T, A>) -> *mut T
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 ptr = Box::into_raw(x);
unsafe {
ptr::drop_in_place(ptr);
dealloc(ptr as *mut u8, Layout::new::<String>());
}
Note: This is equivalent to the following:
let x = Box::new(String::from("Hello"));
let ptr = Box::into_raw(x);
unsafe {
drop(Box::from_raw(ptr));
}
sourcepub fn into_raw_with_allocator(b: Box<T, A>) -> (*mut T, A)
🔬This is a nightly-only experimental API. (allocator_api
)
pub fn into_raw_with_allocator(b: Box<T, A>) -> (*mut T, A)
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>());
}
const: unstable · sourcepub fn allocator(b: &Box<T, A>) -> &A
🔬This is a nightly-only experimental API. (allocator_api
)
pub fn allocator(b: &Box<T, A>) -> &A
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.
1.26.0 · sourcepub fn leak<'a>(b: Box<T, A>) -> &'a mut Twhere
A: 'a,
pub fn leak<'a>(b: Box<T, A>) -> &'a mut Twhere
A: 'a,
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]);
1.63.0 (const: unstable) · sourcepub fn into_pin(boxed: Box<T, A>) -> Pin<Box<T, A>>where
A: 'static,
pub fn into_pin(boxed: Box<T, A>) -> Pin<Box<T, A>>where
A: 'static,
Converts a Box<T>
into a Pin<Box<T>>
. If T
does not implement Unpin
, then
*boxed
will be pinned in memory and unable to be moved.
This conversion does not allocate on the heap and happens in place.
This is also available via From
.
Constructing and pinning a Box
with Box::into_pin(Box::new(x))
can also be written more concisely using Box::pin(x)
.
This into_pin
method is useful if you already have a Box<T>
, or you are
constructing a (pinned) Box
in a different way than with Box::new
.
§Notes
It’s not recommended that crates add an impl like From<Box<T>> for Pin<T>
,
as it’ll introduce an ambiguity when calling Pin::from
.
A demonstration of such a poor impl is shown below.
struct Foo; // A type defined in this crate.
impl From<Box<()>> for Pin<Foo> {
fn from(_: Box<()>) -> Pin<Foo> {
Pin::new(Foo)
}
}
let foo = Box::new(());
let bar = Pin::from(foo);
Trait Implementations
§impl<A, T> ApplicationHandler<T> for Box<A>where
A: ApplicationHandler<T> + ?Sized,
T: 'static,
impl<A, T> ApplicationHandler<T> for Box<A>where
A: ApplicationHandler<T> + ?Sized,
T: 'static,
§fn new_events(&mut self, event_loop: &ActiveEventLoop, cause: StartCause)
fn new_events(&mut self, event_loop: &ActiveEventLoop, cause: StartCause)
§fn resumed(&mut self, event_loop: &ActiveEventLoop)
fn resumed(&mut self, event_loop: &ActiveEventLoop)
§fn user_event(&mut self, event_loop: &ActiveEventLoop, event: T)
fn user_event(&mut self, event_loop: &ActiveEventLoop, event: T)
EventLoopProxy::send_event
.§fn window_event(
&mut self,
event_loop: &ActiveEventLoop,
window_id: WindowId,
event: WindowEvent
)
fn window_event( &mut self, event_loop: &ActiveEventLoop, window_id: WindowId, event: WindowEvent )
§fn device_event(
&mut self,
event_loop: &ActiveEventLoop,
device_id: DeviceId,
event: DeviceEvent
)
fn device_event( &mut self, event_loop: &ActiveEventLoop, device_id: DeviceId, event: DeviceEvent )
§fn about_to_wait(&mut self, event_loop: &ActiveEventLoop)
fn about_to_wait(&mut self, event_loop: &ActiveEventLoop)
§fn suspended(&mut self, event_loop: &ActiveEventLoop)
fn suspended(&mut self, event_loop: &ActiveEventLoop)
§fn exiting(&mut self, event_loop: &ActiveEventLoop)
fn exiting(&mut self, event_loop: &ActiveEventLoop)
§fn memory_warning(&mut self, event_loop: &ActiveEventLoop)
fn memory_warning(&mut self, event_loop: &ActiveEventLoop)
1.64.0 · source§impl<T> AsFd for Box<T>
impl<T> AsFd for Box<T>
source§fn as_fd(&self) -> BorrowedFd<'_>
fn as_fd(&self) -> BorrowedFd<'_>
§impl<T> AsRawXcbConnection for Box<T>where
T: AsRawXcbConnection + ?Sized,
impl<T> AsRawXcbConnection for Box<T>where
T: AsRawXcbConnection + ?Sized,
§fn as_raw_xcb_connection(&self) -> *mut xcb_connection_t
fn as_raw_xcb_connection(&self) -> *mut xcb_connection_t
§impl<T> AsyncBufRead for Box<T>
impl<T> AsyncBufRead for Box<T>
§impl<T> AsyncBufRead for Box<T>
impl<T> AsyncBufRead for Box<T>
source§impl<Args, F, A> AsyncFn<Args> for Box<F, A>
impl<Args, F, A> AsyncFn<Args> for Box<F, A>
source§extern "rust-call" fn async_call(
&self,
args: Args
) -> <Box<F, A> as AsyncFnMut<Args>>::CallRefFuture<'_>
extern "rust-call" fn async_call( &self, args: Args ) -> <Box<F, A> as AsyncFnMut<Args>>::CallRefFuture<'_>
async_fn_traits
)AsyncFn
, returning a future which may borrow from the called closure.source§impl<Args, F, A> AsyncFnMut<Args> for Box<F, A>
impl<Args, F, A> AsyncFnMut<Args> for Box<F, A>
§type CallRefFuture<'a> = <F as AsyncFnMut<Args>>::CallRefFuture<'a>
where
Box<F, A>: 'a
type CallRefFuture<'a> = <F as AsyncFnMut<Args>>::CallRefFuture<'a> where Box<F, A>: 'a
async_fn_traits
)AsyncFnMut::async_call_mut
and AsyncFn::async_call
.source§extern "rust-call" fn async_call_mut(
&mut self,
args: Args
) -> <Box<F, A> as AsyncFnMut<Args>>::CallRefFuture<'_>
extern "rust-call" fn async_call_mut( &mut self, args: Args ) -> <Box<F, A> as AsyncFnMut<Args>>::CallRefFuture<'_>
async_fn_traits
)AsyncFnMut
, returning a future which may borrow from the called closure.source§impl<Args, F, A> AsyncFnOnce<Args> for Box<F, A>
impl<Args, F, A> AsyncFnOnce<Args> for Box<F, A>
§type Output = <F as AsyncFnOnce<Args>>::Output
type Output = <F as AsyncFnOnce<Args>>::Output
async_fn_traits
)§type CallOnceFuture = <F as AsyncFnOnce<Args>>::CallOnceFuture
type CallOnceFuture = <F as AsyncFnOnce<Args>>::CallOnceFuture
async_fn_traits
)AsyncFnOnce::async_call_once
.source§extern "rust-call" fn async_call_once(
self,
args: Args
) -> <Box<F, A> as AsyncFnOnce<Args>>::CallOnceFuture
extern "rust-call" fn async_call_once( self, args: Args ) -> <Box<F, A> as AsyncFnOnce<Args>>::CallOnceFuture
async_fn_traits
)AsyncFnOnce
, returning a future which may move out of the called closure.source§impl<S> AsyncIterator for Box<S>
impl<S> AsyncIterator for Box<S>
§type Item = <S as AsyncIterator>::Item
type Item = <S as AsyncIterator>::Item
async_iterator
)source§fn poll_next(
self: Pin<&mut Box<S>>,
cx: &mut Context<'_>
) -> Poll<Option<<Box<S> as AsyncIterator>::Item>>
fn poll_next( self: Pin<&mut Box<S>>, cx: &mut Context<'_> ) -> Poll<Option<<Box<S> as AsyncIterator>::Item>>
async_iterator
)None
if the async iterator is exhausted. Read more§impl<T> AsyncRead for Box<T>
impl<T> AsyncRead for Box<T>
§impl<T> AsyncWrite for Box<T>
impl<T> AsyncWrite for Box<T>
§fn poll_write(
self: Pin<&mut Box<T>>,
cx: &mut Context<'_>,
buf: &[u8]
) -> Poll<Result<usize, Error>>
fn poll_write( self: Pin<&mut Box<T>>, cx: &mut Context<'_>, buf: &[u8] ) -> Poll<Result<usize, Error>>
buf
into the object. Read more§fn poll_write_vectored(
self: Pin<&mut Box<T>>,
cx: &mut Context<'_>,
bufs: &[IoSlice<'_>]
) -> Poll<Result<usize, Error>>
fn poll_write_vectored( self: Pin<&mut Box<T>>, cx: &mut Context<'_>, bufs: &[IoSlice<'_>] ) -> Poll<Result<usize, Error>>
bufs
into the object using vectored
IO operations. Read more§impl<T> AsyncWrite for Box<T>
impl<T> AsyncWrite for Box<T>
§fn poll_write(
self: Pin<&mut Box<T>>,
cx: &mut Context<'_>,
buf: &[u8]
) -> Poll<Result<usize, Error>>
fn poll_write( self: Pin<&mut Box<T>>, cx: &mut Context<'_>, buf: &[u8] ) -> Poll<Result<usize, Error>>
buf
into the object. Read more§fn poll_write_vectored(
self: Pin<&mut Box<T>>,
cx: &mut Context<'_>,
bufs: &[IoSlice<'_>]
) -> Poll<Result<usize, Error>>
fn poll_write_vectored( self: Pin<&mut Box<T>>, cx: &mut Context<'_>, bufs: &[IoSlice<'_>] ) -> Poll<Result<usize, Error>>
poll_write
, except that it writes from a slice of buffers. Read more§fn is_write_vectored(&self) -> bool
fn is_write_vectored(&self) -> bool
poll_write_vectored
implementation. Read more1.1.0 · source§impl<T, A> BorrowMut<T> for Box<T, A>
impl<T, A> BorrowMut<T> for Box<T, A>
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
§impl<T> Buf for Box<T>where
T: Buf + ?Sized,
impl<T> Buf for Box<T>where
T: Buf + ?Sized,
§fn remaining(&self) -> usize
fn remaining(&self) -> usize
§fn chunk(&self) -> &[u8] ⓘ
fn chunk(&self) -> &[u8] ⓘ
Buf::remaining()
. Note that this can return shorter slice (this allows
non-continuous internal representation). Read more§fn chunks_vectored<'b>(&'b self, dst: &mut [IoSlice<'b>]) -> usize
fn chunks_vectored<'b>(&'b self, dst: &mut [IoSlice<'b>]) -> usize
§fn has_remaining(&self) -> bool
fn has_remaining(&self) -> bool
§fn copy_to_slice(&mut self, dst: &mut [u8])
fn copy_to_slice(&mut self, dst: &mut [u8])
§fn get_u16(&mut self) -> u16
fn get_u16(&mut self) -> u16
self
in big-endian byte order. Read more§fn get_u16_le(&mut self) -> u16
fn get_u16_le(&mut self) -> u16
self
in little-endian byte order. Read more§fn get_u16_ne(&mut self) -> u16
fn get_u16_ne(&mut self) -> u16
self
in native-endian byte order. Read more§fn get_i16(&mut self) -> i16
fn get_i16(&mut self) -> i16
self
in big-endian byte order. Read more§fn get_i16_le(&mut self) -> i16
fn get_i16_le(&mut self) -> i16
self
in little-endian byte order. Read more§fn get_i16_ne(&mut self) -> i16
fn get_i16_ne(&mut self) -> i16
self
in native-endian byte order. Read more§fn get_u32(&mut self) -> u32
fn get_u32(&mut self) -> u32
self
in the big-endian byte order. Read more§fn get_u32_le(&mut self) -> u32
fn get_u32_le(&mut self) -> u32
self
in the little-endian byte order. Read more§fn get_u32_ne(&mut self) -> u32
fn get_u32_ne(&mut self) -> u32
self
in native-endian byte order. Read more§fn get_i32(&mut self) -> i32
fn get_i32(&mut self) -> i32
self
in big-endian byte order. Read more§fn get_i32_le(&mut self) -> i32
fn get_i32_le(&mut self) -> i32
self
in little-endian byte order. Read more§fn get_i32_ne(&mut self) -> i32
fn get_i32_ne(&mut self) -> i32
self
in native-endian byte order. Read more§fn get_u64(&mut self) -> u64
fn get_u64(&mut self) -> u64
self
in big-endian byte order. Read more§fn get_u64_le(&mut self) -> u64
fn get_u64_le(&mut self) -> u64
self
in little-endian byte order. Read more§fn get_u64_ne(&mut self) -> u64
fn get_u64_ne(&mut self) -> u64
self
in native-endian byte order. Read more§fn get_i64(&mut self) -> i64
fn get_i64(&mut self) -> i64
self
in big-endian byte order. Read more§fn get_i64_le(&mut self) -> i64
fn get_i64_le(&mut self) -> i64
self
in little-endian byte order. Read more§fn get_i64_ne(&mut self) -> i64
fn get_i64_ne(&mut self) -> i64
self
in native-endian byte order. Read more§fn get_uint(&mut self, nbytes: usize) -> u64
fn get_uint(&mut self, nbytes: usize) -> u64
self
in big-endian byte order. Read more§fn get_uint_le(&mut self, nbytes: usize) -> u64
fn get_uint_le(&mut self, nbytes: usize) -> u64
self
in little-endian byte order. Read more§fn get_uint_ne(&mut self, nbytes: usize) -> u64
fn get_uint_ne(&mut self, nbytes: usize) -> u64
self
in native-endian byte order. Read more§fn get_int(&mut self, nbytes: usize) -> i64
fn get_int(&mut self, nbytes: usize) -> i64
self
in big-endian byte order. Read more§fn get_int_le(&mut self, nbytes: usize) -> i64
fn get_int_le(&mut self, nbytes: usize) -> i64
self
in little-endian byte order. Read more§fn get_int_ne(&mut self, nbytes: usize) -> i64
fn get_int_ne(&mut self, nbytes: usize) -> i64
self
in native-endian byte order. Read more§fn copy_to_bytes(&mut self, len: usize) -> Bytes
fn copy_to_bytes(&mut self, len: usize) -> Bytes
§fn get_u128(&mut self) -> u128
fn get_u128(&mut self) -> u128
self
in big-endian byte order. Read more§fn get_u128_le(&mut self) -> u128
fn get_u128_le(&mut self) -> u128
self
in little-endian byte order. Read more§fn get_u128_ne(&mut self) -> u128
fn get_u128_ne(&mut self) -> u128
self
in native-endian byte order. Read more§fn get_i128(&mut self) -> i128
fn get_i128(&mut self) -> i128
self
in big-endian byte order. Read more§fn get_i128_le(&mut self) -> i128
fn get_i128_le(&mut self) -> i128
self
in little-endian byte order. Read more§fn get_i128_ne(&mut self) -> i128
fn get_i128_ne(&mut self) -> i128
self
in native-endian byte order. Read more§fn get_f32(&mut self) -> f32
fn get_f32(&mut self) -> f32
self
in big-endian byte order. Read more§fn get_f32_le(&mut self) -> f32
fn get_f32_le(&mut self) -> f32
self
in little-endian byte order. Read more§fn get_f32_ne(&mut self) -> f32
fn get_f32_ne(&mut self) -> f32
self
in native-endian byte order. Read more§fn get_f64(&mut self) -> f64
fn get_f64(&mut self) -> f64
self
in big-endian byte order. Read more§fn get_f64_le(&mut self) -> f64
fn get_f64_le(&mut self) -> f64
self
in little-endian byte order. Read more§fn get_f64_ne(&mut self) -> f64
fn get_f64_ne(&mut self) -> f64
self
in native-endian byte order. Read more§impl<T> BufMut for Box<T>where
T: BufMut + ?Sized,
impl<T> BufMut for Box<T>where
T: BufMut + ?Sized,
§fn remaining_mut(&self) -> usize
fn remaining_mut(&self) -> usize
§fn chunk_mut(&mut self) -> &mut UninitSlice
fn chunk_mut(&mut self) -> &mut UninitSlice
BufMut::remaining_mut()
. Note that this can be shorter than the
whole remainder of the buffer (this allows non-continuous implementation). Read more§unsafe fn advance_mut(&mut self, cnt: usize)
unsafe fn advance_mut(&mut self, cnt: usize)
§fn put_u16(&mut self, n: u16)
fn put_u16(&mut self, n: u16)
self
in big-endian byte order. Read more§fn put_u16_le(&mut self, n: u16)
fn put_u16_le(&mut self, n: u16)
self
in little-endian byte order. Read more§fn put_u16_ne(&mut self, n: u16)
fn put_u16_ne(&mut self, n: u16)
self
in native-endian byte order. Read more§fn put_i16(&mut self, n: i16)
fn put_i16(&mut self, n: i16)
self
in big-endian byte order. Read more§fn put_i16_le(&mut self, n: i16)
fn put_i16_le(&mut self, n: i16)
self
in little-endian byte order. Read more§fn put_i16_ne(&mut self, n: i16)
fn put_i16_ne(&mut self, n: i16)
self
in native-endian byte order. Read more§fn put_u32(&mut self, n: u32)
fn put_u32(&mut self, n: u32)
self
in big-endian byte order. Read more§fn put_u32_le(&mut self, n: u32)
fn put_u32_le(&mut self, n: u32)
self
in little-endian byte order. Read more§fn put_u32_ne(&mut self, n: u32)
fn put_u32_ne(&mut self, n: u32)
self
in native-endian byte order. Read more§fn put_i32(&mut self, n: i32)
fn put_i32(&mut self, n: i32)
self
in big-endian byte order. Read more§fn put_i32_le(&mut self, n: i32)
fn put_i32_le(&mut self, n: i32)
self
in little-endian byte order. Read more§fn put_i32_ne(&mut self, n: i32)
fn put_i32_ne(&mut self, n: i32)
self
in native-endian byte order. Read more§fn put_u64(&mut self, n: u64)
fn put_u64(&mut self, n: u64)
self
in the big-endian byte order. Read more§fn put_u64_le(&mut self, n: u64)
fn put_u64_le(&mut self, n: u64)
self
in little-endian byte order. Read more§fn put_u64_ne(&mut self, n: u64)
fn put_u64_ne(&mut self, n: u64)
self
in native-endian byte order. Read more§fn put_i64(&mut self, n: i64)
fn put_i64(&mut self, n: i64)
self
in the big-endian byte order. Read more§fn put_i64_le(&mut self, n: i64)
fn put_i64_le(&mut self, n: i64)
self
in little-endian byte order. Read more§fn put_i64_ne(&mut self, n: i64)
fn put_i64_ne(&mut self, n: i64)
self
in native-endian byte order. Read more§fn has_remaining_mut(&self) -> bool
fn has_remaining_mut(&self) -> bool
self
for more bytes. Read more§fn put_u128(&mut self, n: u128)
fn put_u128(&mut self, n: u128)
self
in the big-endian byte order. Read more§fn put_u128_le(&mut self, n: u128)
fn put_u128_le(&mut self, n: u128)
self
in little-endian byte order. Read more§fn put_u128_ne(&mut self, n: u128)
fn put_u128_ne(&mut self, n: u128)
self
in native-endian byte order. Read more§fn put_i128(&mut self, n: i128)
fn put_i128(&mut self, n: i128)
self
in the big-endian byte order. Read more§fn put_i128_le(&mut self, n: i128)
fn put_i128_le(&mut self, n: i128)
self
in little-endian byte order. Read more§fn put_i128_ne(&mut self, n: i128)
fn put_i128_ne(&mut self, n: i128)
self
in native-endian byte order. Read more§fn put_uint(&mut self, n: u64, nbytes: usize)
fn put_uint(&mut self, n: u64, nbytes: usize)
self
in big-endian byte order. Read more§fn put_uint_le(&mut self, n: u64, nbytes: usize)
fn put_uint_le(&mut self, n: u64, nbytes: usize)
self
in the little-endian byte order. Read more§fn put_uint_ne(&mut self, n: u64, nbytes: usize)
fn put_uint_ne(&mut self, n: u64, nbytes: usize)
self
in the native-endian byte order. Read more§fn put_int_le(&mut self, n: i64, nbytes: usize)
fn put_int_le(&mut self, n: i64, nbytes: usize)
§fn put_int_ne(&mut self, n: i64, nbytes: usize)
fn put_int_ne(&mut self, n: i64, nbytes: usize)
§fn put_f32(&mut self, n: f32)
fn put_f32(&mut self, n: f32)
self
in big-endian byte order. Read more§fn put_f32_le(&mut self, n: f32)
fn put_f32_le(&mut self, n: f32)
self
in little-endian byte order. Read more§fn put_f32_ne(&mut self, n: f32)
fn put_f32_ne(&mut self, n: f32)
self
in native-endian byte order. Read more§fn put_f64(&mut self, n: f64)
fn put_f64(&mut self, n: f64)
self
in big-endian byte order. Read more§fn put_f64_le(&mut self, n: f64)
fn put_f64_le(&mut self, n: f64)
self
in little-endian byte order. Read more§fn put_f64_ne(&mut self, n: f64)
fn put_f64_ne(&mut self, n: f64)
self
in native-endian byte order. Read more1.0.0 · source§impl<B> BufRead for Box<B>
impl<B> BufRead for Box<B>
source§fn fill_buf(&mut self) -> Result<&[u8], Error>
fn fill_buf(&mut self) -> Result<&[u8], Error>
source§fn consume(&mut self, amt: usize)
fn consume(&mut self, amt: usize)
amt
bytes have been consumed from the buffer,
so they should no longer be returned in calls to read
. Read moresource§fn read_line(&mut self, buf: &mut String) -> Result<usize, Error>
fn read_line(&mut self, buf: &mut String) -> Result<usize, Error>
0xA
byte) is reached, and append
them to the provided String
buffer. Read moresource§fn has_data_left(&mut self) -> Result<bool, Error>
fn has_data_left(&mut self) -> Result<bool, Error>
buf_read_has_data_left
)Read
has any data left to be read. Read moresource§fn skip_until(&mut self, byte: u8) -> Result<usize, Error>
fn skip_until(&mut self, byte: u8) -> Result<usize, Error>
bufread_skip_until
)byte
or EOF is reached. Read more1.0.0 · source§impl<T, A> Clone for Box<T, A>
impl<T, A> Clone for Box<T, A>
source§fn clone(&self) -> Box<T, A>
fn clone(&self) -> Box<T, A>
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);
source§fn clone_from(&mut self, source: &Box<T, A>)
fn clone_from(&mut self, source: &Box<T, A>)
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<C> Connection for Box<C>where
C: Connection + ?Sized,
impl<C> Connection for Box<C>where
C: Connection + ?Sized,
§fn wait_for_event(&self) -> Result<Event, ConnectionError>
fn wait_for_event(&self) -> Result<Event, ConnectionError>
§fn wait_for_raw_event(
&self
) -> Result<<Box<C> as RequestConnection>::Buf, ConnectionError>
fn wait_for_raw_event( &self ) -> Result<<Box<C> as RequestConnection>::Buf, ConnectionError>
§fn wait_for_event_with_sequence(&self) -> Result<(Event, u64), ConnectionError>
fn wait_for_event_with_sequence(&self) -> Result<(Event, u64), ConnectionError>
§fn wait_for_raw_event_with_sequence(
&self
) -> Result<(<Box<C> as RequestConnection>::Buf, u64), ConnectionError>
fn wait_for_raw_event_with_sequence( &self ) -> Result<(<Box<C> as RequestConnection>::Buf, u64), ConnectionError>
§fn poll_for_event(&self) -> Result<Option<Event>, ConnectionError>
fn poll_for_event(&self) -> Result<Option<Event>, ConnectionError>
§fn poll_for_raw_event(
&self
) -> Result<Option<<Box<C> as RequestConnection>::Buf>, ConnectionError>
fn poll_for_raw_event( &self ) -> Result<Option<<Box<C> as RequestConnection>::Buf>, ConnectionError>
§fn poll_for_event_with_sequence(
&self
) -> Result<Option<(Event, u64)>, ConnectionError>
fn poll_for_event_with_sequence( &self ) -> Result<Option<(Event, u64)>, ConnectionError>
§fn poll_for_raw_event_with_sequence(
&self
) -> Result<Option<(<Box<C> as RequestConnection>::Buf, u64)>, ConnectionError>
fn poll_for_raw_event_with_sequence( &self ) -> Result<Option<(<Box<C> as RequestConnection>::Buf, u64)>, ConnectionError>
§fn generate_id(&self) -> Result<u32, ReplyOrIdError>
fn generate_id(&self) -> Result<u32, ReplyOrIdError>
source§impl<G, R, A> Coroutine<R> for Box<G, A>
impl<G, R, A> Coroutine<R> for Box<G, A>
§type Yield = <G as Coroutine<R>>::Yield
type Yield = <G as Coroutine<R>>::Yield
coroutine_trait
)source§impl<'de, T> Deserialize<'de> for Box<T>where
T: Deserialize<'de>,
impl<'de, T> Deserialize<'de> for Box<T>where
T: Deserialize<'de>,
source§fn deserialize<D>(
deserializer: D
) -> Result<Box<T>, <D as Deserializer<'de>>::Error>where
D: Deserializer<'de>,
fn deserialize<D>(
deserializer: D
) -> Result<Box<T>, <D as Deserializer<'de>>::Error>where
D: Deserializer<'de>,
1.0.0 · source§impl<I, A> DoubleEndedIterator for Box<I, A>
impl<I, A> DoubleEndedIterator for Box<I, A>
source§fn next_back(&mut self) -> Option<<I as Iterator>::Item>
fn next_back(&mut self) -> Option<<I as Iterator>::Item>
source§fn nth_back(&mut self, n: usize) -> Option<<I as Iterator>::Item>
fn nth_back(&mut self, n: usize) -> Option<<I as Iterator>::Item>
n
th element from the end of the iterator. Read moresource§fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
iter_advance_by
)n
elements. Read more1.27.0 · source§fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
Iterator::try_fold()
: it takes
elements starting from the back of the iterator. Read more1.8.0 · source§impl<T> Error for Box<T>where
T: Error,
impl<T> Error for Box<T>where
T: Error,
source§fn description(&self) -> &str
fn description(&self) -> &str
source§fn cause(&self) -> Option<&dyn Error>
fn cause(&self) -> Option<&dyn Error>
§impl<T> EventSource for Box<T>where
T: EventSource,
impl<T> EventSource for Box<T>where
T: EventSource,
Blanket implementation for boxed event sources. [EventSource
] is not an
object safe trait, so this does not include trait objects.
§type Error = <T as EventSource>::Error
type Error = <T as EventSource>::Error
process_events()
(not the user callback!).§fn process_events<F>(
&mut self,
readiness: Readiness,
token: Token,
callback: F
) -> Result<PostAction, <Box<T> as EventSource>::Error>
fn process_events<F>( &mut self, readiness: Readiness, token: Token, callback: F ) -> Result<PostAction, <Box<T> as EventSource>::Error>
§fn register(
&mut self,
poll: &mut Poll,
token_factory: &mut TokenFactory
) -> Result<(), Error>
fn register( &mut self, poll: &mut Poll, token_factory: &mut TokenFactory ) -> Result<(), Error>
§fn reregister(
&mut self,
poll: &mut Poll,
token_factory: &mut TokenFactory
) -> Result<(), Error>
fn reregister( &mut self, poll: &mut Poll, token_factory: &mut TokenFactory ) -> Result<(), Error>
§fn unregister(&mut self, poll: &mut Poll) -> Result<(), Error>
fn unregister(&mut self, poll: &mut Poll) -> Result<(), Error>
§const NEEDS_EXTRA_LIFECYCLE_EVENTS: bool = T::NEEDS_EXTRA_LIFECYCLE_EVENTS
const NEEDS_EXTRA_LIFECYCLE_EVENTS: bool = T::NEEDS_EXTRA_LIFECYCLE_EVENTS
EventSource::before_sleep
]
and [EventSource::before_handle_events
] notifications. These are opt-in because
they require more expensive checks, and almost all sources will not need these notifications§fn before_sleep(&mut self) -> Result<Option<(Readiness, Token)>, Error>
fn before_sleep(&mut self) -> Result<Option<(Readiness, Token)>, Error>
poll
is about to begin Read more§fn before_handle_events(&mut self, events: EventIterator<'_>)
fn before_handle_events(&mut self, events: EventIterator<'_>)
EventSource::process_events
] will
be called with the given events for this source. The iterator may be empty,
which indicates that no events were generated for this source Read more1.0.0 · source§impl<I, A> ExactSizeIterator for Box<I, A>
impl<I, A> ExactSizeIterator for Box<I, A>
§impl<F> FusedFuture for Box<F>
impl<F> FusedFuture for Box<F>
§fn is_terminated(&self) -> bool
fn is_terminated(&self) -> bool
true
if the underlying future should no longer be polled.§impl<S> FusedStream for Box<S>
impl<S> FusedStream for Box<S>
§fn is_terminated(&self) -> bool
fn is_terminated(&self) -> bool
true
if the stream should no longer be polled.§impl<H> HasDisplayHandle for Box<H>where
H: HasDisplayHandle + ?Sized,
impl<H> HasDisplayHandle for Box<H>where
H: HasDisplayHandle + ?Sized,
§fn display_handle(&self) -> Result<DisplayHandle<'_>, HandleError>
fn display_handle(&self) -> Result<DisplayHandle<'_>, HandleError>
§impl<H> HasWindowHandle for Box<H>where
H: HasWindowHandle + ?Sized,
impl<H> HasWindowHandle for Box<H>where
H: HasWindowHandle + ?Sized,
§fn window_handle(&self) -> Result<WindowHandle<'_>, HandleError>
fn window_handle(&self) -> Result<WindowHandle<'_>, HandleError>
1.22.0 · source§impl<T, A> Hasher for Box<T, A>
impl<T, A> Hasher for Box<T, A>
source§fn write_u128(&mut self, i: u128)
fn write_u128(&mut self, i: u128)
u128
into this hasher.source§fn write_usize(&mut self, i: usize)
fn write_usize(&mut self, i: usize)
usize
into this hasher.source§fn write_i128(&mut self, i: i128)
fn write_i128(&mut self, i: i128)
i128
into this hasher.source§fn write_isize(&mut self, i: isize)
fn write_isize(&mut self, i: isize)
isize
into this hasher.source§fn write_length_prefix(&mut self, len: usize)
fn write_length_prefix(&mut self, len: usize)
hasher_prefixfree_extras
)§impl<T> ImageDecoder for Box<T>where
T: ImageDecoder + ?Sized,
impl<T> ImageDecoder for Box<T>where
T: ImageDecoder + ?Sized,
§fn dimensions(&self) -> (u32, u32)
fn dimensions(&self) -> (u32, u32)
§fn color_type(&self) -> ColorType
fn color_type(&self) -> ColorType
§fn original_color_type(&self) -> ExtendedColorType
fn original_color_type(&self) -> ExtendedColorType
§fn icc_profile(&mut self) -> Result<Option<Vec<u8>>, ImageError>
fn icc_profile(&mut self) -> Result<Option<Vec<u8>>, ImageError>
Ok(None)
if the image does not have one. Read more§fn total_bytes(&self) -> u64
fn total_bytes(&self) -> u64
§fn read_image(self, buf: &mut [u8]) -> Result<(), ImageError>
fn read_image(self, buf: &mut [u8]) -> Result<(), ImageError>
1.0.0 · source§impl<I, A> Iterator for Box<I, A>
impl<I, A> Iterator for Box<I, A>
source§fn next(&mut self) -> Option<<I as Iterator>::Item>
fn next(&mut self) -> Option<<I as Iterator>::Item>
source§fn size_hint(&self) -> (usize, Option<usize>)
fn size_hint(&self) -> (usize, Option<usize>)
source§fn nth(&mut self, n: usize) -> Option<<I as Iterator>::Item>
fn nth(&mut self, n: usize) -> Option<<I as Iterator>::Item>
n
th element of the iterator. Read moresource§fn last(self) -> Option<<I as Iterator>::Item>
fn last(self) -> Option<<I as Iterator>::Item>
source§fn next_chunk<const N: usize>(
&mut self
) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>where
Self: Sized,
fn next_chunk<const N: usize>(
&mut self
) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>where
Self: Sized,
iter_next_chunk
)N
values. Read more1.0.0 · source§fn count(self) -> usizewhere
Self: Sized,
fn count(self) -> usizewhere
Self: Sized,
source§fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
iter_advance_by
)n
elements. Read more1.28.0 · source§fn step_by(self, step: usize) -> StepBy<Self>where
Self: Sized,
fn step_by(self, step: usize) -> StepBy<Self>where
Self: Sized,
1.0.0 · source§fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
1.0.0 · source§fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>where
Self: Sized,
U: IntoIterator,
fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>where
Self: Sized,
U: IntoIterator,
source§fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
iter_intersperse
)separator
between adjacent items of the original iterator. Read more1.0.0 · source§fn map<B, F>(self, f: F) -> Map<Self, F>
fn map<B, F>(self, f: F) -> Map<Self, F>
1.0.0 · source§fn filter<P>(self, predicate: P) -> Filter<Self, P>
fn filter<P>(self, predicate: P) -> Filter<Self, P>
1.0.0 · source§fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
1.0.0 · source§fn enumerate(self) -> Enumerate<Self>where
Self: Sized,
fn enumerate(self) -> Enumerate<Self>where
Self: Sized,
1.0.0 · source§fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
1.0.0 · source§fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
1.57.0 · source§fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
1.0.0 · source§fn skip(self, n: usize) -> Skip<Self>where
Self: Sized,
fn skip(self, n: usize) -> Skip<Self>where
Self: Sized,
n
elements. Read more1.0.0 · source§fn take(self, n: usize) -> Take<Self>where
Self: Sized,
fn take(self, n: usize) -> Take<Self>where
Self: Sized,
n
elements, or fewer
if the underlying iterator ends sooner. Read more1.0.0 · source§fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
source§fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
iter_map_windows
)f
for each contiguous window of size N
over
self
and returns an iterator over the outputs of f
. Like slice::windows()
,
the windows during mapping overlap as well. Read more1.0.0 · source§fn inspect<F>(self, f: F) -> Inspect<Self, F>
fn inspect<F>(self, f: F) -> Inspect<Self, F>
1.0.0 · source§fn by_ref(&mut self) -> &mut Selfwhere
Self: Sized,
fn by_ref(&mut self) -> &mut Selfwhere
Self: Sized,
source§fn collect_into<E>(self, collection: &mut E) -> &mut E
fn collect_into<E>(self, collection: &mut E) -> &mut E
iter_collect_into
)1.0.0 · source§fn partition<B, F>(self, f: F) -> (B, B)
fn partition<B, F>(self, f: F) -> (B, B)
source§fn is_partitioned<P>(self, predicate: P) -> bool
fn is_partitioned<P>(self, predicate: P) -> bool
iter_is_partitioned
)true
precede all those that return false
. Read more1.27.0 · source§fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
1.27.0 · source§fn try_for_each<F, R>(&mut self, f: F) -> R
fn try_for_each<F, R>(&mut self, f: F) -> R
1.0.0 · source§fn fold<B, F>(self, init: B, f: F) -> B
fn fold<B, F>(self, init: B, f: F) -> B
1.51.0 · source§fn reduce<F>(self, f: F) -> Option<Self::Item>
fn reduce<F>(self, f: F) -> Option<Self::Item>
source§fn try_reduce<F, R>(
&mut self,
f: F
) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
fn try_reduce<F, R>( &mut self, f: F ) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
iterator_try_reduce
)1.0.0 · source§fn all<F>(&mut self, f: F) -> bool
fn all<F>(&mut self, f: F) -> bool
1.0.0 · source§fn any<F>(&mut self, f: F) -> bool
fn any<F>(&mut self, f: F) -> bool
1.0.0 · source§fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
1.30.0 · source§fn find_map<B, F>(&mut self, f: F) -> Option<B>
fn find_map<B, F>(&mut self, f: F) -> Option<B>
source§fn try_find<F, R>(
&mut self,
f: F
) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
fn try_find<F, R>( &mut self, f: F ) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
try_find
)1.0.0 · source§fn position<P>(&mut self, predicate: P) -> Option<usize>
fn position<P>(&mut self, predicate: P) -> Option<usize>
1.6.0 · source§fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
1.15.0 · source§fn max_by<F>(self, compare: F) -> Option<Self::Item>
fn max_by<F>(self, compare: F) -> Option<Self::Item>
1.6.0 · source§fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
1.15.0 · source§fn min_by<F>(self, compare: F) -> Option<Self::Item>
fn min_by<F>(self, compare: F) -> Option<Self::Item>
1.0.0 · source§fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
1.36.0 · source§fn copied<'a, T>(self) -> Copied<Self>
fn copied<'a, T>(self) -> Copied<Self>
source§fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>where
Self: Sized,
fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>where
Self: Sized,
iter_array_chunks
)N
elements of the iterator at a time. Read more1.11.0 · source§fn product<P>(self) -> P
fn product<P>(self) -> P
source§fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
iter_order_by
)Iterator
with those
of another with respect to the specified comparison function. Read more1.5.0 · source§fn partial_cmp<I>(self, other: I) -> Option<Ordering>
fn partial_cmp<I>(self, other: I) -> Option<Ordering>
PartialOrd
elements of
this Iterator
with those of another. The comparison works like short-circuit
evaluation, returning a result without comparing the remaining elements.
As soon as an order can be determined, the evaluation stops and a result is returned. Read moresource§fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>where
Self: Sized,
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>where
Self: Sized,
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
iter_order_by
)Iterator
with those
of another with respect to the specified comparison function. Read moresource§fn eq_by<I, F>(self, other: I, eq: F) -> bool
fn eq_by<I, F>(self, other: I, eq: F) -> bool
iter_order_by
)1.5.0 · source§fn lt<I>(self, other: I) -> bool
fn lt<I>(self, other: I) -> bool
Iterator
are lexicographically
less than those of another. Read more1.5.0 · source§fn le<I>(self, other: I) -> bool
fn le<I>(self, other: I) -> bool
Iterator
are lexicographically
less or equal to those of another. Read more1.5.0 · source§fn gt<I>(self, other: I) -> bool
fn gt<I>(self, other: I) -> bool
Iterator
are lexicographically
greater than those of another. Read more1.5.0 · source§fn ge<I>(self, other: I) -> bool
fn ge<I>(self, other: I) -> bool
Iterator
are lexicographically
greater than or equal to those of another. Read moresource§fn is_sorted_by<F>(self, compare: F) -> bool
fn is_sorted_by<F>(self, compare: F) -> bool
is_sorted
)source§fn is_sorted_by_key<F, K>(self, f: F) -> bool
fn is_sorted_by_key<F, K>(self, f: F) -> bool
is_sorted
)1.0.0 · source§impl<T, A> Ord for Box<T, A>
impl<T, A> Ord for Box<T, A>
1.0.0 · source§impl<T, A> PartialEq for Box<T, A>
impl<T, A> PartialEq for Box<T, A>
1.0.0 · source§impl<T, A> PartialOrd for Box<T, A>
impl<T, A> PartialOrd for Box<T, A>
source§fn le(&self, other: &Box<T, A>) -> bool
fn le(&self, other: &Box<T, A>) -> bool
self
and other
) and is used by the <=
operator. Read more1.0.0 · source§impl<R> Read for Box<R>
impl<R> Read for Box<R>
source§fn read(&mut self, buf: &mut [u8]) -> Result<usize, Error>
fn read(&mut self, buf: &mut [u8]) -> Result<usize, Error>
source§fn read_buf(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>
fn read_buf(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>
read_buf
)source§fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>
fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>
read
, except that it reads into a slice of buffers. Read moresource§fn is_read_vectored(&self) -> bool
fn is_read_vectored(&self) -> bool
can_vector
)source§fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Error>
fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Error>
buf
. Read moresource§fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>
fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>
buf
. Read moresource§fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>
fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>
buf
. Read moresource§fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>
fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>
read_buf
)cursor
. Read more1.0.0 · source§fn by_ref(&mut self) -> &mut Selfwhere
Self: Sized,
fn by_ref(&mut self) -> &mut Selfwhere
Self: Sized,
Read
. Read more§impl<C> RequestConnection for Box<C>where
C: RequestConnection + ?Sized,
impl<C> RequestConnection for Box<C>where
C: RequestConnection + ?Sized,
§type Buf = <C as RequestConnection>::Buf
type Buf = <C as RequestConnection>::Buf
§fn send_request_with_reply<R>(
&self,
bufs: &[IoSlice<'_>],
fds: Vec<OwnedFd>
) -> Result<Cookie<'_, Box<C>, R>, ConnectionError>where
R: TryParse,
fn send_request_with_reply<R>(
&self,
bufs: &[IoSlice<'_>],
fds: Vec<OwnedFd>
) -> Result<Cookie<'_, Box<C>, R>, ConnectionError>where
R: TryParse,
§fn send_trait_request_with_reply<R>(
&self,
request: R
) -> Result<Cookie<'_, Box<C>, <R as ReplyRequest>::Reply>, ConnectionError>where
R: ReplyRequest,
fn send_trait_request_with_reply<R>(
&self,
request: R
) -> Result<Cookie<'_, Box<C>, <R as ReplyRequest>::Reply>, ConnectionError>where
R: ReplyRequest,
§fn send_request_with_reply_with_fds<R>(
&self,
bufs: &[IoSlice<'_>],
fds: Vec<OwnedFd>
) -> Result<CookieWithFds<'_, Box<C>, R>, ConnectionError>where
R: TryParseFd,
fn send_request_with_reply_with_fds<R>(
&self,
bufs: &[IoSlice<'_>],
fds: Vec<OwnedFd>
) -> Result<CookieWithFds<'_, Box<C>, R>, ConnectionError>where
R: TryParseFd,
§fn send_trait_request_with_reply_with_fds<R>(
&self,
request: R
) -> Result<CookieWithFds<'_, Box<C>, <R as ReplyFDsRequest>::Reply>, ConnectionError>where
R: ReplyFDsRequest,
fn send_trait_request_with_reply_with_fds<R>(
&self,
request: R
) -> Result<CookieWithFds<'_, Box<C>, <R as ReplyFDsRequest>::Reply>, ConnectionError>where
R: ReplyFDsRequest,
§fn send_request_without_reply(
&self,
bufs: &[IoSlice<'_>],
fds: Vec<OwnedFd>
) -> Result<VoidCookie<'_, Box<C>>, ConnectionError>
fn send_request_without_reply( &self, bufs: &[IoSlice<'_>], fds: Vec<OwnedFd> ) -> Result<VoidCookie<'_, Box<C>>, ConnectionError>
§fn send_trait_request_without_reply<R>(
&self,
request: R
) -> Result<VoidCookie<'_, Box<C>>, ConnectionError>where
R: VoidRequest,
fn send_trait_request_without_reply<R>(
&self,
request: R
) -> Result<VoidCookie<'_, Box<C>>, ConnectionError>where
R: VoidRequest,
§fn discard_reply(&self, sequence: u64, kind: RequestKind, mode: DiscardMode)
fn discard_reply(&self, sequence: u64, kind: RequestKind, mode: DiscardMode)
§fn prefetch_extension_information(
&self,
extension_name: &'static str
) -> Result<(), ConnectionError>
fn prefetch_extension_information( &self, extension_name: &'static str ) -> Result<(), ConnectionError>
§fn extension_information(
&self,
extension_name: &'static str
) -> Result<Option<ExtensionInformation>, ConnectionError>
fn extension_information( &self, extension_name: &'static str ) -> Result<Option<ExtensionInformation>, ConnectionError>
§fn wait_for_reply_or_error(
&self,
sequence: u64
) -> Result<<Box<C> as RequestConnection>::Buf, ReplyError>
fn wait_for_reply_or_error( &self, sequence: u64 ) -> Result<<Box<C> as RequestConnection>::Buf, ReplyError>
§fn wait_for_reply_or_raw_error(
&self,
sequence: u64
) -> Result<ReplyOrError<<Box<C> as RequestConnection>::Buf>, ConnectionError>
fn wait_for_reply_or_raw_error( &self, sequence: u64 ) -> Result<ReplyOrError<<Box<C> as RequestConnection>::Buf>, ConnectionError>
§fn wait_for_reply(
&self,
sequence: u64
) -> Result<Option<<Box<C> as RequestConnection>::Buf>, ConnectionError>
fn wait_for_reply( &self, sequence: u64 ) -> Result<Option<<Box<C> as RequestConnection>::Buf>, ConnectionError>
§fn wait_for_reply_with_fds(
&self,
sequence: u64
) -> Result<(<Box<C> as RequestConnection>::Buf, Vec<OwnedFd>), ReplyError>
fn wait_for_reply_with_fds( &self, sequence: u64 ) -> Result<(<Box<C> as RequestConnection>::Buf, Vec<OwnedFd>), ReplyError>
§fn wait_for_reply_with_fds_raw(
&self,
sequence: u64
) -> Result<ReplyOrError<(<Box<C> as RequestConnection>::Buf, Vec<OwnedFd>), <Box<C> as RequestConnection>::Buf>, ConnectionError>
fn wait_for_reply_with_fds_raw( &self, sequence: u64 ) -> Result<ReplyOrError<(<Box<C> as RequestConnection>::Buf, Vec<OwnedFd>), <Box<C> as RequestConnection>::Buf>, ConnectionError>
§fn check_for_error(&self, sequence: u64) -> Result<(), ReplyError>
fn check_for_error(&self, sequence: u64) -> Result<(), ReplyError>
§fn check_for_raw_error(
&self,
sequence: u64
) -> Result<Option<<Box<C> as RequestConnection>::Buf>, ConnectionError>
fn check_for_raw_error( &self, sequence: u64 ) -> Result<Option<<Box<C> as RequestConnection>::Buf>, ConnectionError>
§fn prefetch_maximum_request_bytes(&self)
fn prefetch_maximum_request_bytes(&self)
§fn maximum_request_bytes(&self) -> usize
fn maximum_request_bytes(&self) -> usize
§fn parse_error(&self, error: &[u8]) -> Result<X11Error, ParseError>
fn parse_error(&self, error: &[u8]) -> Result<X11Error, ParseError>
§fn parse_event(&self, event: &[u8]) -> Result<Event, ParseError>
fn parse_event(&self, event: &[u8]) -> Result<Event, ParseError>
source§impl<R> RngCore for Box<R>
impl<R> RngCore for Box<R>
source§fn fill_bytes(&mut self, dest: &mut [u8])
fn fill_bytes(&mut self, dest: &mut [u8])
dest
with random data. Read more1.0.0 · source§impl<S> Seek for Box<S>
impl<S> Seek for Box<S>
source§fn seek(&mut self, pos: SeekFrom) -> Result<u64, Error>
fn seek(&mut self, pos: SeekFrom) -> Result<u64, Error>
source§fn stream_position(&mut self) -> Result<u64, Error>
fn stream_position(&mut self) -> Result<u64, Error>
1.55.0 · source§fn rewind(&mut self) -> Result<(), Error>
fn rewind(&mut self) -> Result<(), Error>
source§impl<T> Serialize for Box<T>
impl<T> Serialize for Box<T>
source§fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,
fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,
§impl<S, Item> Sink<Item> for Box<S>
impl<S, Item> Sink<Item> for Box<S>
§fn poll_ready(
self: Pin<&mut Box<S>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <Box<S> as Sink<Item>>::Error>>
fn poll_ready( self: Pin<&mut Box<S>>, cx: &mut Context<'_> ) -> Poll<Result<(), <Box<S> as Sink<Item>>::Error>>
Sink
to receive a value. Read more§fn start_send(
self: Pin<&mut Box<S>>,
item: Item
) -> Result<(), <Box<S> as Sink<Item>>::Error>
fn start_send( self: Pin<&mut Box<S>>, item: Item ) -> Result<(), <Box<S> as Sink<Item>>::Error>
poll_ready
which returned Poll::Ready(Ok(()))
. Read more§impl<T> Source for Box<T>where
T: Source + ?Sized,
impl<T> Source for Box<T>where
T: Source + ?Sized,
§impl<S> Stream for Box<S>
impl<S> Stream for Box<S>
§impl<S> Subscriber for Box<S>where
S: Subscriber + ?Sized,
impl<S> Subscriber for Box<S>where
S: Subscriber + ?Sized,
§fn register_callsite(&self, metadata: &'static Metadata<'static>) -> Interest
fn register_callsite(&self, metadata: &'static Metadata<'static>) -> Interest
§fn max_level_hint(&self) -> Option<LevelFilter>
fn max_level_hint(&self) -> Option<LevelFilter>
Subscriber
will
enable, or None
, if the subscriber does not implement level-based
filtering or chooses not to implement this method. Read more§fn record_follows_from(&self, span: &Id, follows: &Id)
fn record_follows_from(&self, span: &Id, follows: &Id)
§fn event_enabled(&self, event: &Event<'_>) -> bool
fn event_enabled(&self, event: &Event<'_>) -> bool
Event
] should be recorded. Read more§fn clone_span(&self, id: &Id) -> Id
fn clone_span(&self, id: &Id) -> Id
§fn drop_span(&self, id: Id)
fn drop_span(&self, id: Id)
Subscriber::try_close
instead§fn current_span(&self) -> Current
fn current_span(&self) -> Current
§unsafe fn downcast_raw(&self, id: TypeId) -> Option<*const ()>
unsafe fn downcast_raw(&self, id: TypeId) -> Option<*const ()>
self
is the same type as the provided TypeId
, returns an untyped
*const
pointer to that type. Otherwise, returns None
. Read more§fn on_register_dispatch(&self, subscriber: &Dispatch)
fn on_register_dispatch(&self, subscriber: &Dispatch)
Dispatch
]. Read moresource§impl<T> ToTokens for Box<T>
impl<T> ToTokens for Box<T>
source§fn to_tokens(&self, tokens: &mut TokenStream)
fn to_tokens(&self, tokens: &mut TokenStream)
source§fn to_token_stream(&self) -> TokenStream
fn to_token_stream(&self) -> TokenStream
source§fn into_token_stream(self) -> TokenStreamwhere
Self: Sized,
fn into_token_stream(self) -> TokenStreamwhere
Self: Sized,
1.0.0 · source§impl<W> Write for Box<W>
impl<W> Write for Box<W>
source§fn write(&mut self, buf: &[u8]) -> Result<usize, Error>
fn write(&mut self, buf: &[u8]) -> Result<usize, Error>
source§fn is_write_vectored(&self) -> bool
fn is_write_vectored(&self) -> bool
can_vector
)