Trait gclient::ext::sp_core::sp_std::ops::Drop

1.0.0 · source ·
pub trait Drop {
    // Required method
    fn drop(&mut self);
}
Expand description

Custom code within the destructor.

When a value is no longer needed, Rust will run a “destructor” on that value. The most common way that a value is no longer needed is when it goes out of scope. Destructors may still run in other circumstances, but we’re going to focus on scope for the examples here. To learn about some of those other cases, please see the reference section on destructors.

This destructor consists of two components:

  • A call to Drop::drop for that value, if this special Drop trait is implemented for its type.
  • The automatically generated “drop glue” which recursively calls the destructors of all the fields of this value.

As Rust automatically calls the destructors of all contained fields, you don’t have to implement Drop in most cases. But there are some cases where it is useful, for example for types which directly manage a resource. That resource may be memory, it may be a file descriptor, it may be a network socket. Once a value of that type is no longer going to be used, it should “clean up” its resource by freeing the memory or closing the file or socket. This is the job of a destructor, and therefore the job of Drop::drop.

§Examples

To see destructors in action, let’s take a look at the following program:

struct HasDrop;

impl Drop for HasDrop {
    fn drop(&mut self) {
        println!("Dropping HasDrop!");
    }
}

struct HasTwoDrops {
    one: HasDrop,
    two: HasDrop,
}

impl Drop for HasTwoDrops {
    fn drop(&mut self) {
        println!("Dropping HasTwoDrops!");
    }
}

fn main() {
    let _x = HasTwoDrops { one: HasDrop, two: HasDrop };
    println!("Running!");
}

Rust will first call Drop::drop for _x and then for both _x.one and _x.two, meaning that running this will print

Running!
Dropping HasTwoDrops!
Dropping HasDrop!
Dropping HasDrop!

Even if we remove the implementation of Drop for HasTwoDrop, the destructors of its fields are still called. This would result in

Running!
Dropping HasDrop!
Dropping HasDrop!

§You cannot call Drop::drop yourself

Because Drop::drop is used to clean up a value, it may be dangerous to use this value after the method has been called. As Drop::drop does not take ownership of its input, Rust prevents misuse by not allowing you to call Drop::drop directly.

In other words, if you tried to explicitly call Drop::drop in the above example, you’d get a compiler error.

If you’d like to explicitly call the destructor of a value, mem::drop can be used instead.

§Drop order

Which of our two HasDrop drops first, though? For structs, it’s the same order that they’re declared: first one, then two. If you’d like to try this yourself, you can modify HasDrop above to contain some data, like an integer, and then use it in the println! inside of Drop. This behavior is guaranteed by the language.

Unlike for structs, local variables are dropped in reverse order:

struct Foo;

impl Drop for Foo {
    fn drop(&mut self) {
        println!("Dropping Foo!")
    }
}

struct Bar;

impl Drop for Bar {
    fn drop(&mut self) {
        println!("Dropping Bar!")
    }
}

fn main() {
    let _foo = Foo;
    let _bar = Bar;
}

This will print

Dropping Bar!
Dropping Foo!

Please see the reference for the full rules.

§Copy and Drop are exclusive

You cannot implement both Copy and Drop on the same type. Types that are Copy get implicitly duplicated by the compiler, making it very hard to predict when, and how often destructors will be executed. As such, these types cannot have destructors.

§Drop check

Dropping interacts with the borrow checker in subtle ways: when a type T is being implicitly dropped as some variable of this type goes out of scope, the borrow checker needs to ensure that calling T’s destructor at this moment is safe. In particular, it also needs to be safe to recursively drop all the fields of T. For example, it is crucial that code like the following is being rejected:

use std::cell::Cell;

struct S<'a>(Cell<Option<&'a S<'a>>>, Box<i32>);
impl Drop for S<'_> {
    fn drop(&mut self) {
        if let Some(r) = self.0.get() {
            // Print the contents of the `Box` in `r`.
            println!("{}", r.1);
        }
    }
}

fn main() {
    // Set up two `S` that point to each other.
    let s1 = S(Cell::new(None), Box::new(42));
    let s2 = S(Cell::new(Some(&s1)), Box::new(42));
    s1.0.set(Some(&s2));
    // Now they both get dropped. But whichever is the 2nd one
    // to be dropped will access the `Box` in the first one,
    // which is a use-after-free!
}

The Nomicon discusses the need for drop check in more detail.

To reject such code, the “drop check” analysis determines which types and lifetimes need to still be live when T gets dropped. The exact details of this analysis are not yet stably guaranteed and subject to change. Currently, the analysis works as follows:

  • If T has no drop glue, then trivially nothing is required to be live. This is the case if neither T nor any of its (recursive) fields have a destructor (impl Drop). PhantomData and ManuallyDrop are considered to never have a destructor, no matter their field type.
  • If T has drop glue, then, for all types U that are owned by any field of T, recursively add the types and lifetimes that need to be live when U gets dropped. The set of owned types is determined by recursively traversing T:
    • Recursively descend through PhantomData, Box, tuples, and arrays (including arrays of length 0).
    • Stop at reference and raw pointer types as well as function pointers and function items; they do not own anything.
    • Stop at non-composite types (type parameters that remain generic in the current context and base types such as integers and bool); these types are owned.
    • When hitting an ADT with impl Drop, stop there; this type is owned.
    • When hitting an ADT without impl Drop, recursively descend to its fields. (For an enum, consider all fields of all variants.)
  • Furthermore, if T implements Drop, then all generic (lifetime and type) parameters of T must be live.

In the above example, the last clause implies that 'a must be live when S<'a> is dropped, and hence the example is rejected. If we remove the impl Drop, the liveness requirement disappears and the example is accepted.

There exists an unstable way for a type to opt-out of the last clause; this is called “drop check eyepatch” or may_dangle. For more details on this nightly-only feature, see the discussion in the Nomicon.

Required Methods§

source

fn drop(&mut self)

Executes the destructor for this type.

This method is called implicitly when the value goes out of scope, and cannot be called explicitly (this is compiler error E0040). However, the mem::drop function in the prelude can be used to call the argument’s Drop implementation.

When this method has been called, self has not yet been deallocated. That only happens after the method is over. If this wasn’t the case, self would be a dangling reference.

§Panics

Implementations should generally avoid panic!ing, because drop() may itself be called during unwinding due to a panic, and if the drop() panics in that situation (a “double panic”), this will likely abort the program. It is possible to check panicking() first, which may be desirable for a Drop implementation that is reporting a bug of the kind “you didn’t finish using this before it was dropped”; but most types should simply clean up their owned allocations or other resources and return normally from drop(), regardless of what state they are in.

Note that even if this panics, the value is considered to be dropped; you must not cause drop to be called again. This is normally automatically handled by the compiler, but when using unsafe code, can sometimes occur unintentionally, particularly when using ptr::drop_in_place.

Implementors§

source§

impl Drop for Node

§

impl Drop for Pair

1.13.0 · source§

impl Drop for CString

1.6.0 · source§

impl Drop for gclient::ext::sp_core::bounded::alloc::string::Drain<'_>

§

impl Drop for OffchainState

1.36.0 · source§

impl Drop for Waker

1.63.0 · source§

impl Drop for OwnedFd

source§

impl Drop for Error

source§

impl Drop for RecvStream

source§

impl Drop for Taker

§

impl Drop for AbortGuard

§

impl Drop for AbortHandle

§

impl Drop for Allocation

§

impl Drop for Ast

A custom Drop impl is used for Ast such that it uses constant stack space but heap space proportional to the depth of the Ast.

§

impl Drop for Ast

A custom Drop impl is used for Ast such that it uses constant stack space but heap space proportional to the depth of the Ast.

§

impl Drop for BacktraceFrameFmt<'_, '_, '_>

§

impl Drop for Bytes

§

impl Drop for BytesMut

§

impl Drop for CancellationToken

§

impl Drop for ClassSet

A custom Drop impl is used for ClassSet such that it uses constant stack space but heap space proportional to the depth of the ClassSet.

§

impl Drop for ClassSet

A custom Drop impl is used for ClassSet such that it uses constant stack space but heap space proportional to the depth of the ClassSet.

§

impl Drop for Client

§

impl Drop for Client

§

impl Drop for CodeMemory

§

impl Drop for DefaultGuard

§

impl Drop for Delay

§

impl Drop for DropGuard

§

impl Drop for DuplexStream

§

impl Drop for Enter

§

impl Drop for EnteredSpan

§

impl Drop for Event

§

impl Drop for EventListener

§

impl Drop for Features

§

impl Drop for FreeingBumpHeapAllocator

§

impl Drop for GaiFuture

§

impl Drop for GdbJitImageRegistration

§

impl Drop for Hir

A custom Drop impl is used for HirKind such that it uses constant stack space but heap space proportional to the depth of the total Hir.

§

impl Drop for Hir

A custom Drop impl is used for HirKind such that it uses constant stack space but heap space proportional to the depth of the total Hir.

§

impl Drop for Keypair

§

impl Drop for LocalEnterGuard

§

impl Drop for LocalSet

§

impl Drop for LockGuard

§

impl Drop for MemoryImageSlot

§

impl Drop for Mmap

§

impl Drop for Module

§

impl Drop for Notified<'_>

§

impl Drop for OwnedSemaphorePermit

§

impl Drop for OwnedWriteHalf

§

impl Drop for OwnedWriteHalf

§

impl Drop for ProtectGuard

§

impl Drop for ResourceGuard

§

impl Drop for Runtime

§

impl Drop for SemaphoreGuard<'_>

§

impl Drop for SemaphoreGuardArc

§

impl Drop for SemaphorePermit<'_>

§

impl Drop for SigningKey

§

impl Drop for Span

§

impl Drop for Subscription

§

impl Drop for SubscriptionSink

§

impl Drop for Table

§

impl Drop for ThreadPool

§

impl Drop for VMExternRef

§

impl Drop for WabtBuf

source§

impl<'a> Drop for PathSegmentsMut<'a>

source§

impl<'a> Drop for UrlQuery<'a>

§

impl<'a> Drop for Entered<'a>

§

impl<'a> Drop for MethodResourcesBuilder<'a>

§

impl<'a, 'b, L> Drop for StorageLockGuard<'a, 'b, L>
where L: Lockable,

source§

impl<'a, A> Drop for arrayvec::Drain<'a, A>
where A: Array, <A as Array>::Item: 'a,

source§

impl<'a, A> Drop for arrayvec::Drain<'a, A>
where A: Array, <A as Array>::Item: 'a,

§

impl<'a, B, H, Exec> Drop for StateMachine<'a, B, H, Exec>
where H: Hasher, B: Backend<H>,

§

impl<'a, K, F, A> Drop for DrainFilter<'a, K, F, A>
where A: Allocator + Clone, F: FnMut(&K) -> bool,

§

impl<'a, K, F, A> Drop for DrainFilter<'a, K, F, A>
where A: Allocator + Clone, F: FnMut(&K) -> bool,

§

impl<'a, K, V, F, A> Drop for DrainFilter<'a, K, V, F, A>
where F: FnMut(&K, &mut V) -> bool, A: Allocator + Clone,

§

impl<'a, K, V, F, A> Drop for DrainFilter<'a, K, V, F, A>
where F: FnMut(&K, &mut V) -> bool, A: Allocator + Clone,

§

impl<'a, K, V, L, S> Drop for Drain<'a, K, V, L, S>
where K: PartialEq + Hash, S: BuildHasher, L: Limiter<K, V>,

§

impl<'a, L> Drop for TrieDBMut<'a, L>
where L: TrieLayout,

§

impl<'a, R, G, T> Drop for MappedReentrantMutexGuard<'a, R, G, T>
where R: RawMutex + 'a, G: GetThreadId + 'a, T: 'a + ?Sized,

§

impl<'a, R, G, T> Drop for ReentrantMutexGuard<'a, R, G, T>
where R: RawMutex + 'a, G: GetThreadId + 'a, T: 'a + ?Sized,

§

impl<'a, R, T> Drop for MappedMutexGuard<'a, R, T>
where R: RawMutex + 'a, T: 'a + ?Sized,

§

impl<'a, R, T> Drop for MappedRwLockReadGuard<'a, R, T>
where R: RawRwLock + 'a, T: 'a + ?Sized,

§

impl<'a, R, T> Drop for MappedRwLockWriteGuard<'a, R, T>
where R: RawRwLock + 'a, T: 'a + ?Sized,

§

impl<'a, R, T> Drop for MutexGuard<'a, R, T>
where R: RawMutex + 'a, T: 'a + ?Sized,

§

impl<'a, R, T> Drop for RwLockReadGuard<'a, R, T>
where R: RawRwLock + 'a, T: 'a + ?Sized,

§

impl<'a, R, T> Drop for RwLockUpgradableReadGuard<'a, R, T>
where R: RawRwLockUpgrade + 'a, T: 'a + ?Sized,

§

impl<'a, R, T> Drop for RwLockWriteGuard<'a, R, T>
where R: RawRwLock + 'a, T: 'a + ?Sized,

source§

impl<'a, T> Drop for http::header::map::Drain<'a, T>

source§

impl<'a, T> Drop for ValueDrain<'a, T>

source§

impl<'a, T> Drop for Locked<'a, T>

§

impl<'a, T> Drop for Drain<'a, T>
where T: 'a + Array,

§

impl<'a, T> Drop for MappedMutexGuard<'a, T>
where T: ?Sized,

§

impl<'a, T> Drop for MutexGuard<'a, T>
where T: ?Sized,

§

impl<'a, T> Drop for RwLockMappedWriteGuard<'a, T>
where T: ?Sized,

§

impl<'a, T> Drop for RwLockReadGuard<'a, T>
where T: ?Sized,

§

impl<'a, T> Drop for RwLockUpgradableReadGuard<'a, T>
where T: ?Sized,

§

impl<'a, T> Drop for RwLockWriteGuard<'a, T>
where T: ?Sized,

§

impl<'a, T> Drop for RwLockWriteGuard<'a, T>
where T: ?Sized,

source§

impl<'a, T, A> Drop for DrainSorted<'a, T, A>
where T: Ord, A: Allocator,

source§

impl<'a, T, C> Drop for Ref<'a, T, C>
where T: Clear + Default, C: Config,

source§

impl<'a, T, C> Drop for RefMut<'a, T, C>
where T: Clear + Default, C: Config,

source§

impl<'a, T, C> Drop for Entry<'a, T, C>
where C: Config,

source§

impl<'a, T, const CAP: usize> Drop for arrayvec::arrayvec::Drain<'a, T, CAP>
where T: 'a,

§

impl<'e, E, W> Drop for EncoderWriter<'e, E, W>
where E: Engine, W: Write,

source§

impl<'f> Drop for VaListImpl<'f>

§

impl<'p, 's, T> Drop for SliceVecDrain<'p, 's, T>
where T: Default,

§

impl<'p, A, I> Drop for ArrayVecSplice<'p, A, I>
where A: Array, I: Iterator<Item = <A as Array>::Item>,

§

impl<'p, A, I> Drop for TinyVecSplice<'p, A, I>
where A: Array, I: Iterator<Item = <A as Array>::Item>,

§

impl<'rwlock, T> Drop for RwLockReadGuard<'rwlock, T>
where T: ?Sized,

§

impl<'rwlock, T> Drop for RwLockUpgradeableGuard<'rwlock, T>
where T: ?Sized,

§

impl<'rwlock, T> Drop for RwLockWriteGuard<'rwlock, T>
where T: ?Sized,

source§

impl<A> Drop for RepeatN<A>

source§

impl<A> Drop for arrayvec::ArrayVec<A>
where A: Array,

source§

impl<A> Drop for arrayvec::ArrayVec<A>
where A: Array,

source§

impl<A> Drop for arrayvec::IntoIter<A>
where A: Array,

source§

impl<A> Drop for arrayvec::IntoIter<A>
where A: Array,

§

impl<A> Drop for IntoIter<A>
where A: Array,

§

impl<A> Drop for SmallVec<A>
where A: Array,

§

impl<C> Drop for Secp256k1<C>
where C: Context,

§

impl<F> Drop for DeferGuard<F>
where F: FnOnce(),

§

impl<Fut> Drop for FuturesUnordered<Fut>

§

impl<Fut> Drop for Shared<Fut>
where Fut: Future,

§

impl<H> Drop for LocalTrieCache<H>
where H: Hasher,

1.21.0 · source§

impl<I, A> Drop for gclient::ext::sp_core::bounded::alloc::vec::Splice<'_, I, A>
where I: Iterator, A: Allocator,

§

impl<I, A> Drop for Splice<'_, I, A>
where I: Iterator, A: Allocator,

§

impl<I, K, V, S> Drop for Splice<'_, I, K, V, S>
where I: Iterator<Item = (K, V)>, K: Hash + Eq, S: BuildHasher,

1.7.0 · source§

impl<K, V, A> Drop for gclient::ext::sp_core::bounded::alloc::collections::btree_map::IntoIter<K, V, A>
where A: Allocator + Clone,

1.7.0 · source§

impl<K, V, A> Drop for BTreeMap<K, V, A>
where A: Allocator + Clone,

§

impl<M, T, O> Drop for BitRef<'_, M, T, O>
where M: Mutability, T: BitStore, O: BitOrder,

§

impl<Notif> Drop for Subscription<Notif>

§

impl<Notif> Drop for Subscription<Notif>

source§

impl<S> Drop for Secret<S>
where S: Zeroize,

source§

impl<T> Drop for ThinBox<T>
where T: ?Sized,

source§

impl<T> Drop for UniqueRc<T>

source§

impl<T> Drop for gclient::ext::sp_core::sp_std::sync::MutexGuard<'_, T>
where T: ?Sized,

1.70.0 · source§

impl<T> Drop for OnceLock<T>

source§

impl<T> Drop for gclient::ext::sp_core::sp_std::sync::RwLockReadGuard<'_, T>
where T: ?Sized,

source§

impl<T> Drop for gclient::ext::sp_core::sp_std::sync::RwLockWriteGuard<'_, T>
where T: ?Sized,

source§

impl<T> Drop for http::header::map::IntoIter<T>

§

impl<T> Drop for AsyncFd<T>
where T: AsRawFd,

§

impl<T> Drop for BiLockGuard<'_, T>

§

impl<T> Drop for Instrumented<T>

§

impl<T> Drop for JoinHandle<T>

§

impl<T> Drop for JoinSet<T>

§

impl<T> Drop for LocalFutureObj<'_, T>

§

impl<T> Drop for MutexGuard<'_, T>
where T: ?Sized,

§

impl<T> Drop for MutexGuard<'_, T>
where T: ?Sized,

§

impl<T> Drop for MutexGuard<'_, T>
where T: ?Sized,

§

impl<T> Drop for MutexGuardArc<T>
where T: ?Sized,

§

impl<T> Drop for MutexLockFuture<'_, T>
where T: ?Sized,

§

impl<T> Drop for NoDrop<T>

§

impl<T> Drop for OnceBox<T>

§

impl<T> Drop for OnceCell<T>

§

impl<T> Drop for OnceCell<T>

§

impl<T> Drop for OwnedMutexGuard<T>
where T: ?Sized,

§

impl<T> Drop for OwnedMutexGuard<T>
where T: ?Sized,

§

impl<T> Drop for OwnedMutexLockFuture<T>
where T: ?Sized,

§

impl<T> Drop for OwnedPermit<T>

§

impl<T> Drop for OwnedRwLockWriteGuard<T>
where T: ?Sized,

§

impl<T> Drop for Permit<'_, T>

§

impl<T> Drop for PermitIterator<'_, T>

§

impl<T> Drop for Receiver<T>

§

impl<T> Drop for Receiver<T>

§

impl<T> Drop for Receiver<T>

§

impl<T> Drop for Receiver<T>

§

impl<T> Drop for Receiver<T>

§

impl<T> Drop for RwLockReadGuard<'_, T>
where T: ?Sized,

§

impl<T> Drop for RwLockReadGuardArc<T>

§

impl<T> Drop for RwLockUpgradableReadGuardArc<T>
where T: ?Sized,

§

impl<T> Drop for RwLockWriteGuardArc<T>
where T: ?Sized,

§

impl<T> Drop for Sender<T>

§

impl<T> Drop for Sender<T>

§

impl<T> Drop for Sender<T>

§

impl<T> Drop for Sender<T>

§

impl<T> Drop for Store<T>

§

impl<T> Drop for ThreadLocal<T>
where T: Send,

§

impl<T> Drop for UnboundedReceiver<T>

§

impl<T> Drop for UpgradeArc<T>
where T: ?Sized,

§

impl<T> Drop for WeakSender<T>

§

impl<T> Drop for WeakUnboundedSender<T>

source§

impl<T, A> Drop for gclient::ext::sp_runtime::app_crypto::Vec<T, A>
where A: Allocator,

1.12.0 · source§

impl<T, A> Drop for PeekMut<'_, T, A>
where T: Ord, A: Allocator,

source§

impl<T, A> Drop for LinkedList<T, A>
where A: Allocator,

source§

impl<T, A> Drop for VecDeque<T, A>
where A: Allocator,

1.6.0 · source§

impl<T, A> Drop for gclient::ext::sp_core::bounded::alloc::collections::vec_deque::Drain<'_, T, A>
where A: Allocator,

source§

impl<T, A> Drop for Rc<T, A>
where A: Allocator, T: ?Sized,

1.4.0 · source§

impl<T, A> Drop for gclient::ext::sp_core::bounded::alloc::rc::Weak<T, A>
where A: Allocator, T: ?Sized,

1.6.0 · source§

impl<T, A> Drop for gclient::ext::sp_core::bounded::alloc::vec::Drain<'_, T, A>
where A: Allocator,

source§

impl<T, A> Drop for gclient::ext::sp_core::bounded::alloc::vec::IntoIter<T, A>
where A: Allocator,

source§

impl<T, A> Drop for gclient::ext::sp_core::sp_std::prelude::Box<T, A>
where A: Allocator, T: ?Sized,

source§

impl<T, A> Drop for Arc<T, A>
where A: Allocator, T: ?Sized,

1.4.0 · source§

impl<T, A> Drop for gclient::ext::sp_core::sp_std::sync::Weak<T, A>
where A: Allocator, T: ?Sized,

§

impl<T, A> Drop for Box<T, A>
where A: Allocator, T: ?Sized,

§

impl<T, A> Drop for Drain<'_, T, A>
where A: Allocator,

§

impl<T, A> Drop for IntoIter<T, A>
where A: Allocator,

§

impl<T, A> Drop for RawDrain<'_, T, A>
where A: Allocator + Clone,

§

impl<T, A> Drop for RawDrain<'_, T, A>
where A: Allocator + Clone,

§

impl<T, A> Drop for RawDrain<'_, T, A>
where A: Allocator,

§

impl<T, A> Drop for RawIntoIter<T, A>
where A: Allocator + Clone,

§

impl<T, A> Drop for RawIntoIter<T, A>
where A: Allocator + Clone,

§

impl<T, A> Drop for RawIntoIter<T, A>
where A: Allocator,

§

impl<T, A> Drop for RawTable<T, A>
where A: Allocator + Clone,

§

impl<T, A> Drop for RawTable<T, A>
where A: Allocator + Clone,

§

impl<T, A> Drop for RawTable<T, A>
where A: Allocator,

§

impl<T, A> Drop for Vec<T, A>
where A: Allocator,

source§

impl<T, C> Drop for OwnedRef<T, C>
where T: Clear + Default, C: Config,

source§

impl<T, C> Drop for OwnedRefMut<T, C>
where T: Clear + Default, C: Config,

source§

impl<T, C> Drop for OwnedEntry<T, C>
where C: Config,

source§

impl<T, F> Drop for LazyLock<T, F>

§

impl<T, F> Drop for TaskLocalFuture<T, F>
where T: 'static,

source§

impl<T, F, A> Drop for ExtractIf<'_, T, F, A>
where A: Allocator, F: FnMut(&mut T) -> bool,

source§

impl<T, F, S> Drop for ScopeGuard<T, F, S>
where F: FnOnce(T), S: Strategy,

§

impl<T, N> Drop for GenericArrayIter<T, N>
where N: ArrayLength<T>,

§

impl<T, N> Drop for GenericArrayIter<T, N>
where N: ArrayLength<T>,

§

impl<T, O> Drop for BitBox<T, O>
where T: BitStore, O: BitOrder,

§

impl<T, O> Drop for BitVec<T, O>
where T: BitStore, O: BitOrder,

§

impl<T, O> Drop for Drain<'_, T, O>
where T: BitStore, O: BitOrder,

§

impl<T, O, I> Drop for Splice<'_, T, O, I>
where T: BitStore, O: BitOrder, I: Iterator<Item = bool>,

§

impl<T, U> Drop for Cow<'_, T, U>
where T: Beef + ?Sized, U: Capacity,

§

impl<T, U> Drop for MappedMutexGuard<'_, T, U>
where T: ?Sized, U: ?Sized,

§

impl<T, U> Drop for OwnedMappedMutexGuard<T, U>
where T: ?Sized, U: ?Sized,

§

impl<T, U> Drop for OwnedRwLockMappedWriteGuard<T, U>
where T: ?Sized, U: ?Sized,

§

impl<T, U> Drop for OwnedRwLockReadGuard<T, U>
where T: ?Sized, U: ?Sized,

source§

impl<T, const CAP: usize> Drop for arrayvec::arrayvec::ArrayVec<T, CAP>

source§

impl<T, const CAP: usize> Drop for arrayvec::arrayvec::IntoIter<T, CAP>

1.40.0 · source§

impl<T, const N: usize> Drop for core::array::iter::IntoIter<T, N>

§

impl<Target> Drop for FilelikeView<'_, Target>
where Target: FilelikeViewType,

§

impl<Target> Drop for SocketlikeView<'_, Target>
where Target: SocketlikeViewType,

source§

impl<W> Drop for BufWriter<W>
where W: Write + ?Sized,

§

impl<W> Drop for EncoderWriter<W>
where W: Write,

§

impl<Z> Drop for Zeroizing<Z>
where Z: Zeroize,