Deepsize

https://docs.rs/deepsize/0.2.0
Admin
Deepsize is a Rust utility for recursively measuring the size of objects and their heap allocations,...
Tokens:12,500
Snippets:74
Trust Score:9.1
Update:6 months ago
Show doc for...
Tokens:
Raw
### known_deep_size Usage Example

Source: https://docs.rs/deepsize/0.2.0/deepsize/macro.known_deep_size.html

Examples of applying the macro to structs with and without heap allocations.

```rust
struct A(u32);
struct B(A, char);
struct C(Box<u32>);

known_deep_size!(0; A, B); // A and B do not have any allocation
known_deep_size!(4; C); // C will always have an allocation of 4 bytes
```

--------------------------------

### Calculate Deep Size of Vec

Source: https://docs.rs/deepsize/0.2.0/src/deepsize/lib.rs.html

Examples demonstrating how to calculate the deep size of a Vec, accounting for capacity and child object sizes.

```rust
use deepsize::DeepSizeOf;

let mut vec: Vec<u8> = vec![];
for i in 0..13 {
    vec.push(i);
}

// The capacity (16) plus three usizes (len, cap, pointer)
assert_eq!(vec.deep_size_of(), 16 + 24);
```

```rust
use deepsize::DeepSizeOf;

let mut vec: Vec<Box<u64>> = vec![];
for i in 0..13 {
    vec.push(Box::new(i));
}

// The capacity (16?) * size (8) plus three usizes (len, cap, pointer)
// and length (13) * the allocated size of each object
assert_eq!(vec.deep_size_of(), 24 + vec.capacity() * 8 + 13 * 8);
```

--------------------------------

### DeepSizeOf Usage Example

Source: https://docs.rs/deepsize/0.2.0/deepsize/trait.DeepSizeOf.html

Demonstrates how to use the `deep_size_of` method on a `Vec` containing `Box<u32>` and `String` elements. The assertion checks the total estimated size, including the Vec's overhead, element overhead, and string content sizes.

```rust
use deepsize::DeepSizeOf;

let mut map: Vec<(Box<u32>, String)> = Vec::new();

map.push((Box::new(42u32), String::from("Hello World")));
map.push((Box::new(20u32), String::from("Something")));
map.push((Box::new(0u32),  String::from("A string")));
map.push((Box::new(255u32), String::from("Dynamically Allocated!")));

assert_eq!(map.deep_size_of(),
    std::mem::size_of::<Vec<(Box<u32>, String)>>() +
    4 * std::mem::size_of::<(Box<u32>, String)>() +
    4 * std::mem::size_of::<u32>() +
    11 + 9 + 8 + 22
);
```

--------------------------------

### Implement DeepSizeOf for Vec

Source: https://docs.rs/deepsize/0.2.0/src/deepsize/lib.rs.html

Example implementation of deep_size_of_children for a collection type like Vec.

```rust
# use deepsize::{DeepSizeOf, Context};
impl<T> DeepSizeOf for std::vec::Vec<T> where T: DeepSizeOf {
    fn deep_size_of_children(&self, context: &mut Context) -> usize {
        // Size of heap allocations for each child
        self.iter().map(|child| child.deep_size_of_children(context)).sum()
         + self.capacity() * std::mem::size_of::<T>()  // Size of Vec's heap allocation
```

--------------------------------

### Derive DeepSizeOf for a Struct

Source: https://docs.rs/deepsize/0.2.0/deepsize/index.html

Use the `#[derive(DeepSizeOf)]` macro to automatically implement the `DeepSizeOf` trait for your structs. This example shows its application on a struct containing a u32 and a Box.

```rust
use deepsize::DeepSizeOf;

#[derive(DeepSizeOf)]
struct Test {
    a: u32,
    b: Box<u8>,
}

let object = Test {
    a: 15,
    b: Box::new(255),
};

// The stack size of the struct:
//    The size of a u32 (4)
//    4 bytes padding (64 bit only)
//    The stack size of the Box (a usize pointer, 32 or 64 bits: 4 or 8 bytes)
// + the size of a u8 (1), the Box's heap storage
#[cfg(target_pointer_width = "64")]
assert_eq!(object.deep_size_of(), 17);
#[cfg(target_pointer_width = "32")]
assert_eq!(object.deep_size_of(), 9);
```

--------------------------------

### Macros and Structs

Source: https://docs.rs/deepsize/0.2.0/index.html

Overview of the available macros and internal structures provided by the deepsize crate.

```APIDOC
## Macros
- **known_deep_size**: A macro to generate an impl for types with known inner allocation sizes.

## Structs
- **Context**: Represents the context of which references have already been seen. Used primarily within the implementation of the `deep_size_of_children` function.
```

--------------------------------

### Array Implementations

Source: https://docs.rs/deepsize/0.2.0/deepsize/trait.DeepSizeOf.html

Demonstrates the DeepSizeOf implementation for arrays of varying sizes.

```APIDOC
## impl<T: DeepSizeOf> DeepSizeOf for [T; 30]

### Description
Implementation of DeepSizeOf for an array of 30 elements.

### Method
fn deep_size_of_children(&self, context: &mut Context) -> usize

### Endpoint
N/A (Trait implementation)

## impl<T: DeepSizeOf> DeepSizeOf for [T; 31]

### Description
Implementation of DeepSizeOf for an array of 31 elements.

### Method
fn deep_size_of_children(&self, context: &mut Context) -> usize

### Endpoint
N/A (Trait implementation)

## impl<T: DeepSizeOf> DeepSizeOf for [T; 32]

### Description
Implementation of DeepSizeOf for an array of 32 elements.

### Method
fn deep_size_of_children(&self, context: &mut Context) -> usize

### Endpoint
N/A (Trait implementation)
```

--------------------------------

### RwLock Implementation

Source: https://docs.rs/deepsize/0.2.0/deepsize/trait.DeepSizeOf.html

Details the DeepSizeOf implementation for an RwLock, including potential deadlocks and poisoned states.

```APIDOC
## impl<T: DeepSizeOf> DeepSizeOf for RwLock<T>

### Description
Implementation of DeepSizeOf for an `RwLock<T>`. This reads the `RwLock`, so it may deadlock. If the lock is poisoned, this returns 0.

### Method
fn deep_size_of_children(&self, context: &mut Context) -> usize

### Endpoint
N/A (Trait implementation)
```

--------------------------------

### Implement DeepSizeOf for standard library types

Source: https://docs.rs/deepsize/0.2.0/src/deepsize/default_impls.rs.html

Implementations for common types like String, Option, Result, and synchronization primitives.

```rust
impl DeepSizeOf for alloc::string::String {
    fn deep_size_of_children(&self, _: &mut Context) -> usize {
        self.capacity()
    }
}
```

```rust
impl<T: DeepSizeOf> DeepSizeOf for core::option::Option<T> {
    fn deep_size_of_children(&self, context: &mut Context) -> usize {
        match &self {
            Some(t) => t.deep_size_of_children(context),
            None => 0,
        }
    }
}
```

```rust
impl<R: DeepSizeOf, E: DeepSizeOf> DeepSizeOf for core::result::Result<R, E> {
    fn deep_size_of_children(&self, context: &mut Context) -> usize {
        match &self {
            Ok(r) => r.deep_size_of_children(context),
            Err(e) => e.deep_size_of_children(context),
        }
    }
}
```

```rust
impl<T: DeepSizeOf> DeepSizeOf for core::cell::RefCell<T> {
    fn deep_size_of_children(&self, context: &mut Context) -> usize {
        self.borrow().deep_size_of_children(context)
    }
}
```

```rust
impl<T: DeepSizeOf> DeepSizeOf for std::sync::Mutex<T> {
    /// This locks the `Mutex`, so it may deadlock; If the mutex is
    /// poisoned, this returns 0
    fn deep_size_of_children(&self, context: &mut Context) -> usize {
        self.lock()
            .map(|s| s.deep_size_of_children(context))
            .unwrap_or(0)
    }
}
```

```rust
impl<T: DeepSizeOf> DeepSizeOf for std::sync::RwLock<T> {
    /// This reads the `RwLock`, so it may deadlock; If the lock is
    /// poisoned, this returns 0
    fn deep_size_of_children(&self, context: &mut Context) -> usize {
        self.read()
            .map(|s| s.deep_size_of_children(context))
            .unwrap_or(0)
    }
}
```

--------------------------------

### PhantomData Implementation

Source: https://docs.rs/deepsize/0.2.0/deepsize/trait.DeepSizeOf.html

Details the DeepSizeOf implementation for PhantomData.

```APIDOC
## impl<T: ?Sized> DeepSizeOf for PhantomData<T>

### Description
Implementation of DeepSizeOf for `PhantomData<T>`.

### Method
fn deep_size_of_children(&self, _: &mut Context) -> usize

### Endpoint
N/A (Trait implementation)
```

--------------------------------

### DeepSizeOf Trait and Derive Macro Usage

Source: https://docs.rs/deepsize/0.2.0/deepsize

Demonstrates how to use the `DeepSizeOf` trait and its associated derive macro to measure the size of custom structs.

```APIDOC
## Crate deepsize

A utility for recursively measuring the size of an object.
This contains the `DeepSizeOf` trait, and re-exports the `DeepSizeOf` derive macro from `deepsize_derive`.

### Usage Example

```rust
use deepsize::DeepSizeOf;

#[derive(DeepSizeOf)]
struct Test {
    a: u32,
    b: Box<u8>,
}

let object = Test {
    a: 15,
    b: Box::new(255),
};

// The stack size of the struct:
//    The size of a u32 (4)
//    4 bytes padding (64 bit only)
//    The stack size of the Box (a usize pointer, 32 or 64 bits: 4 or 8 bytes)
// + the size of a u8 (1), the Box's heap storage
#[cfg(target_pointer_width = "64")]
assert_eq!(object.deep_size_of(), 17);
#[cfg(target_pointer_width = "32")]
assert_eq!(object.deep_size_of(), 9);
```

### Macros

*   `known_deep_size`: A macro to generate an impl for types with known inner allocation sizes.

### Structs

*   `Context`: The context of which references have already been seen. This should only be used in the implementation of the `deep_size_of_children` function, and (eventually, when this reaches 0.2) will not be able to be constructed, and only obtained from inside the function.

### Traits

*   `DeepSizeOf`: A trait for measuring the size of an object and its children.

### Derive Macros

*   `DeepSizeOf`
```

--------------------------------

### RefCell Implementation

Source: https://docs.rs/deepsize/0.2.0/deepsize/trait.DeepSizeOf.html

Details the DeepSizeOf implementation for a RefCell.

```APIDOC
## impl<T: DeepSizeOf> DeepSizeOf for RefCell<T>

### Description
Implementation of DeepSizeOf for a `RefCell<T>`.

### Method
fn deep_size_of_children(&self, context: &mut Context) -> usize

### Endpoint
N/A (Trait implementation)
```

--------------------------------

### Implement DeepSizeOf for References

Source: https://docs.rs/deepsize/0.2.0/src/deepsize/lib.rs.html

References are treated as non-owned and return 0 for deep size calculation.

```rust
impl<T> DeepSizeOf for &T
where
    T: DeepSizeOf + ?Sized,
{
    fn deep_size_of_children(&self, _context: &mut Context) -> usize {
        0
        // if context.contains_ref(&self) {
        //     0
        // } else {
        //     context.add_ref(&self);
        //     size_of_val(*self) + (*self).deep_size_of_children(context)
        // }
    }
}
```

```rust
impl<T> DeepSizeOf for &mut T
where
    T: DeepSizeOf + ?Sized,
{
    fn deep_size_of_children(&self, _context: &mut Context) -> usize {
        0
    }
}
```

--------------------------------

### Mutex Implementation

Source: https://docs.rs/deepsize/0.2.0/deepsize/trait.DeepSizeOf.html

Details the DeepSizeOf implementation for a Mutex, including potential deadlocks and poisoned states.

```APIDOC
## impl<T: DeepSizeOf> DeepSizeOf for Mutex<T>

### Description
Implementation of DeepSizeOf for a `Mutex<T>`. This locks the `Mutex`, so it may deadlock. If the mutex is poisoned, this returns 0.

### Method
fn deep_size_of_children(&self, context: &mut Context) -> usize

### Endpoint
N/A (Trait implementation)
```

--------------------------------

### Calculate deep size of LinkedList

Source: https://docs.rs/deepsize/0.2.0/deepsize/trait.DeepSizeOf.html

Demonstrates calculating the deep size of a LinkedList, accounting for node overhead.

```rust
use deepsize::DeepSizeOf;
use std::collections::LinkedList;

let mut list: LinkedList<u8> = LinkedList::new();
for i in 0..12 {
    list.push_back(i);
}
list.push_front(13);

assert_eq!(list.deep_size_of(), std::mem::size_of::<LinkedList<u8>>()
                               + 13 * 1 + 13 * 2 * 8);
```

--------------------------------

### Calculate deep size of VecDeque

Source: https://docs.rs/deepsize/0.2.0/deepsize/trait.DeepSizeOf.html

Demonstrates calculating the deep size of a VecDeque, including capacity and allocated objects.

```rust
use deepsize::DeepSizeOf;
use std::collections::VecDeque;

let mut vec: VecDeque<u8> = VecDeque::new();
for i in 0..12 {
    vec.push_back(i);
}
vec.push_front(13);

// The capacity (15?) plus four usizes (start, end, cap, pointer)
assert_eq!(vec.deep_size_of(), vec.capacity() * 1 + 32);
```

```rust
use deepsize::DeepSizeOf;
use std::collections::VecDeque;

let mut vec: VecDeque<Box<u64>> = VecDeque::new();
for i in 0..12 {
    vec.push_back(Box::new(i));
}
vec.push_front(Box::new(13));

// The capacity (15?) * size (8) plus four usizes (start, end, cap, pointer)
// and length (13) * the allocated size of each object
assert_eq!(vec.deep_size_of(), 32 + vec.capacity() * 8 + 13 * 8);
```

--------------------------------

### Implement Debug for Context

Source: https://docs.rs/deepsize/0.2.0/deepsize/struct.Context.html

Provides a Debug implementation for the Context struct, allowing it to be formatted for debugging purposes. This is part of the standard trait implementations for the struct.

```rust
impl Debug for Context
Source§
#### fn fmt(&self, f: &mut Formatter<'_>) -> Result
Formats the value using the given formatter. Read more
```

--------------------------------

### Instantiate DeepSizeOf for Array Lengths 0-32

Source: https://docs.rs/deepsize/0.2.0/src/deepsize/default_impls.rs.html

This code instantiates the `deep_size_array` macro for array lengths from 0 to 32, covering common array sizes.

```Rust
deep_size_array!(
    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
    26, 27, 28, 29, 30, 31, 32
);
```

--------------------------------

### Instantiate DeepSizeOf for Tuples of Arity 1-10

Source: https://docs.rs/deepsize/0.2.0/src/deepsize/default_impls.rs.html

These code snippets instantiate the `deep_size_tuple` macro for tuples with 1 to 10 elements, enabling deep size calculation for various tuple configurations.

```Rust
deep_size_tuple!((0, A));
```

```Rust
deep_size_tuple!((0, A), (1, B));
```

```Rust
deep_size_tuple!((0, A), (1, B), (2, C));
```

```Rust
deep_size_tuple!((0, A), (1, B), (2, C), (3, D));
```

```Rust
deep_size_tuple!((0, A), (1, B), (2, C), (3, D), (4, E));
```

```Rust
deep_size_tuple!((0, A), (1, B), (2, C), (3, D), (4, E), (5, F));
```

```Rust
deep_size_tuple!((0, A), (1, B), (2, C), (3, D), (4, E), (5, F), (6, G));
```

```Rust
deep_size_tuple!(
    (0, A),
    (1, B),
    (2, C),
    (3, D),
    (4, E),
    (5, F),
    (6, G),
    (7, H)
);
```

```Rust
deep_size_tuple!(
    (0, A),
    (1, B),
    (2, C),
    (3, D),
    (4, E),
    (5, F),
    (6, G),
    (7, H),
    (8, I)
);
```

```Rust
deep_size_tuple!(
    (0, A),
    (1, B),
    (2, C),
    (3, D),
    (4, E),
    (5, F),
    (6, G),
    (7, H),
    (8, I),
    (9, J)
);
```

--------------------------------

### Implement DeepSizeOf for BTree-like structures

Source: https://docs.rs/deepsize/0.2.0/src/deepsize/lib.rs.html

Calculates the deep size of children for BTree-like structures by folding over elements and adding calculated overhead.

```rust
fn deep_size_of_children(&self, context: &mut Context) -> usize {
        let element_size = self
            .iter()
            .fold(0, |sum, item| sum + item.deep_size_of_children(context));
        let overhead = size_of::<(usize, u16, u16, [K; BTREE_MAX], [usize; BTREE_B])>();
        element_size + self.len() * overhead * 2 / (BTREE_MAX + BTREE_MIN)
    }
}
```

--------------------------------

### known_deep_size Macro

Source: https://docs.rs/deepsize/0.2.0/deepsize/macro.known_deep_size.html

A macro to generate an implementation for types with known inner allocation sizes, repurposed from the heapsize crate.

```APIDOC
## Macro: known_deep_size

### Description
A macro to generate an impl for types with known inner allocation sizes. This is useful for types that do not contain heap-allocated data or have a fixed, known allocation size.

### Usage
```rust
struct A(u32);
struct B(A, char);
struct C(Box<u32>);

// A and B do not have any allocation
known_deep_size!(0; A, B);

// C will always have an allocation of 4 bytes
known_deep_size!(4; C);
```

### Syntax
- `known_deep_size!($size:expr; $($({$($gen:tt)*})? $type:ty,)+)`
- `known_deep_size!($size:expr; $($({$($gen:tt)*})? $type:ty),+)`
```

--------------------------------

### DeepSizeOf for IndexSet<K, S>

Source: https://docs.rs/deepsize/0.2.0/src/deepsize/external_impls.rs.html

Calculates the deep size of an IndexSet, considering its capacity and the size of its elements. Requires K to implement DeepSizeOf.

```rust
impl<K, S> DeepSizeOf for IndexSet<K, S>
    where K: DeepSizeOf
{
    fn deep_size_of_children(&self, context: &mut Context) -> usize {
        let child_sizes = self.iter().fold(0, |sum, key| {
            sum + key.deep_size_of_children(context)
        });
        let map_size = self.capacity() * (size_of::<(usize, K, ())>() + size_of::<usize>());
        child_sizes + map_size
    }
}
```

--------------------------------

### Implement DeepSizeOf for Arc and Rc

Source: https://docs.rs/deepsize/0.2.0/src/deepsize/lib.rs.html

Tracks visited smart pointers in the context to prevent double-counting shared memory.

```rust
impl<T> DeepSizeOf for alloc::sync::Arc<T>
where
    T: DeepSizeOf + ?Sized,
{
    fn deep_size_of_children(&self, context: &mut Context) -> usize {
        if context.contains_arc(self) {
            0
        } else {
            context.add_arc(self);
            let val: &T = &*self;
            // Size of the Arc, size of the value, size of the allocations of the value
            size_of_val(val) + val.deep_size_of_children(context)
        }
    }
}
```

```rust
impl<T> DeepSizeOf for alloc::rc::Rc<T>
where
    T: DeepSizeOf + ?Sized,
{
    fn deep_size_of_children(&self, context: &mut Context) -> usize {
        if context.contains_rc(self) {
            0
        } else {
            context.add_rc(self);
            let val: &T = &*self;
            size_of_val(val) + val.deep_size_of_children(context)
        }
    }
}
```

--------------------------------

### VecDeque DeepSizeOf Implementation

Source: https://docs.rs/deepsize/0.2.0/deepsize/trait.DeepSizeOf.html

Implementation of DeepSizeOf for VecDeque, accounting for capacity and allocated objects.

```APIDOC
## impl<T> DeepSizeOf for VecDeque<T>

### Description
Sums the size of each child object and adds the size of the unused capacity in the buffer.

### Request Example
```rust
use deepsize::DeepSizeOf;
use std::collections::VecDeque;

let mut vec: VecDeque<u8> = VecDeque::new();
for i in 0..12 { vec.push_back(i); }
vec.push_front(13);

assert_eq!(vec.deep_size_of(), vec.capacity() * 1 + 32);
```
```

--------------------------------

### Measure object size with DeepSizeOf

Source: https://docs.rs/deepsize/0.2.0/deepsize

Use the DeepSizeOf derive macro to automatically implement size measurement for structs. The result includes both stack and heap-allocated memory.

```rust
use deepsize::DeepSizeOf;

#[derive(DeepSizeOf)]
struct Test {
    a: u32,
    b: Box<u8>,
}

let object = Test {
    a: 15,
    b: Box::new(255),
};

// The stack size of the struct:
//    The size of a u32 (4)
//    4 bytes padding (64 bit only)
//    The stack size of the Box (a usize pointer, 32 or 64 bits: 4 or 8 bytes)
// + the size of a u8 (1), the Box's heap storage
#[cfg(target_pointer_width = "64")]
assert_eq!(object.deep_size_of(), 17);
#[cfg(target_pointer_width = "32")]
assert_eq!(object.deep_size_of(), 9);
```

--------------------------------

### Define known allocation sizes with known_deep_size macro

Source: https://docs.rs/deepsize/0.2.0/src/deepsize/default_impls.rs.html

Use this macro to implement DeepSizeOf for types where the allocation size is known at compile time. It supports generic types and multiple type definitions.

```rust
/// Usage:
/// ```rust
/// # #[macro_use] extern crate deepsize; fn main() {
/// struct A(u32);
/// struct B(A, char);
/// struct C(Box<u32>);
///
/// known_deep_size!(0; A, B); // A and B do not have any allocation
/// known_deep_size!(4; C); // C will always have an allocation of 4 bytes
/// # }
/// ```
#[macro_export]
macro_rules! known_deep_size (
    ($size:expr; $($({$($gen:tt)*})? $type:ty,)+) => (
        known_deep_size!($size; $($({$($gen)*})? $type),*);
    );
    ($size:expr; $($({$($gen:tt)*})? $type:ty),+) => (
        $(
            impl$(<$($gen)*>)? $crate::DeepSizeOf for $type {
                #[inline(always)]
                fn deep_size_of_children(&self, _: &mut $crate::Context) -> usize {
                    $size
                }
            }
        )+
    );
);
```

--------------------------------

### DeepSizeOf Trait Usage

Source: https://docs.rs/deepsize/0.2.0/index.html

Demonstrates how to use the DeepSizeOf derive macro to measure the total size of a struct including its heap-allocated contents.

```APIDOC
## DeepSizeOf Trait

### Description
A trait for measuring the size of an object and its children. It is typically implemented via the provided derive macro.

### Usage Example
```rust
use deepsize::DeepSizeOf;

#[derive(DeepSizeOf)]
struct Test {
    a: u32,
    b: Box<u8>,
}

let object = Test {
    a: 15,
    b: Box::new(255),
};

// Returns the total size including heap allocations
object.deep_size_of();
```
```

--------------------------------

### Struct: Context

Source: https://docs.rs/deepsize/0.2.0/deepsize/struct.Context.html

The Context struct maintains a record of visited references to ensure accurate memory size calculation when recursing through data structures.

```APIDOC
## Struct Context

### Description
The Context struct is used to track references (such as Arc and Rc) that have already been visited. It must be passed between deep_size_of_children calls during recursion to prevent double-counting of memory usage.

### Usage
This struct is intended for use within the implementation of the `deep_size_of_children` function. It is not meant to be constructed manually by the end user.
```

--------------------------------

### Implement Any for T

Source: https://docs.rs/deepsize/0.2.0/deepsize/struct.Context.html

Blanket implementation of the `Any` trait for any type `T` that is `'static` and `?Sized`. This allows types to be downcastable and queried for their `TypeId`.

```rust
impl<T> Any for T
where T: 'static + ?Sized,
Source§
#### fn type_id(&self) -> TypeId
Gets the `TypeId` of `self`. Read more
```

--------------------------------

### Implement DeepSizeOf for external collections

Source: https://docs.rs/deepsize/0.2.0/src/deepsize/external_impls.rs.html

These implementations use conditional compilation features to provide deep size calculation for common Rust data structures.

```rust
#[cfg(feature = "slotmap")]
mod slotmap_impl {
    use crate::{known_deep_size, Context, DeepSizeOf};
    use core::mem::size_of;

    known_deep_size!(0; slotmap::KeyData, slotmap::DefaultKey);

    impl<K, V> DeepSizeOf for slotmap::SlotMap<K, V>
    where
        K: DeepSizeOf + slotmap::Key,
        V: DeepSizeOf + slotmap::Slottable,
    {
        fn deep_size_of_children(&self, context: &mut Context) -> usize {
            self.iter().fold(0, |sum, (key, val)| {
                sum + key.deep_size_of_children(context) + val.deep_size_of_children(context)
            }) + self.capacity() * size_of::<(u32, V)>()
        }
    }
}
```

```rust
#[cfg(feature = "slab")]
mod slab_impl {
    use crate::{Context, DeepSizeOf};
    use core::mem::size_of;

    // Mirror's `slab`'s internal `Entry` struct
    enum MockEntry<T> {
        _Vacant(usize),
        _Occupied(T),
    }

    impl<T> DeepSizeOf for slab::Slab<T>
    where
        T: DeepSizeOf,
    {
        fn deep_size_of_children(&self, context: &mut Context) -> usize {
            let capacity_size = self.capacity() * size_of::<MockEntry<T>>();
            let owned_size = self
                .iter()
                .fold(0, |sum, (_, val)| sum + val.deep_size_of_children(context));
            capacity_size + owned_size
        }
    }
}
```

```rust
#[cfg(feature = "arrayvec")]
mod arrayvec_impl {
    use crate::{known_deep_size, Context, DeepSizeOf};

    impl<A> DeepSizeOf for arrayvec::ArrayVec<A>
    where
        A: arrayvec::Array,
        <A as arrayvec::Array>::Item: DeepSizeOf,
    {
        fn deep_size_of_children(&self, context: &mut Context) -> usize {
            self.iter()
                .fold(0, |sum, elem| sum + elem.deep_size_of_children(context))
        }
    }

    known_deep_size!(0; { A: arrayvec::Array<Item=u8> + Copy } arrayvec::ArrayString<A>);
}
```

```rust
#[cfg(feature = "smallvec")]
mod smallvec_impl {
    use crate::{Context, DeepSizeOf};
    use core::mem::size_of;

    impl<A> DeepSizeOf for smallvec::SmallVec<A>
    where
        A: smallvec::Array,
        <A as smallvec::Array>::Item: DeepSizeOf,
    {
        fn deep_size_of_children(&self, context: &mut Context) -> usize {
            let child_size = self
                .iter()
                .fold(0, |sum, elem| sum + elem.deep_size_of_children(context));
            if self.spilled() {
                child_size + self.capacity() * size_of::<<A as smallvec::Array>::Item>()
            } else {
                child_size
            }
        }
    }
}
```

```rust
#[cfg(feature = "hashbrown")]
mod hashbrown_impl {
    use crate::{Context, DeepSizeOf};
    use core::mem::size_of;

    // This is probably still incorrect, but it's better than before
    impl<K, V, S> DeepSizeOf for hashbrown::HashMap<K, V, S>
    where
        K: DeepSizeOf + Eq + std::hash::Hash,
        V: DeepSizeOf,
        S: std::hash::BuildHasher,
    {
        fn deep_size_of_children(&self, context: &mut Context) -> usize {
            self.iter().fold(0, |sum, (key, val)| {
                sum + key.deep_size_of_children(context) + val.deep_size_of_children(context)
            }) + self.capacity() * size_of::<(K, V)>()
            // Buckets would be the more correct value, but there isn't
            // an API for accessing that with hashbrown.
            // I believe that hashbrown's HashTable is represented as
            // an array of (K, V), with control bytes at the start/end
            // that mark used/uninitialized buckets (?)
        }
    }

    impl<K, S> DeepSizeOf for hashbrown::HashSet<K, S>
    where
        K: DeepSizeOf + Eq + std::hash::Hash,
        S: std::hash::BuildHasher,
    {
        fn deep_size_of_children(&self, context: &mut Context) -> usize {
            self.iter()
                .fold(0, |sum, key| sum + key.deep_size_of_children(context))
                + self.capacity() * size_of::<K>()
        }
    }
}
```

```rust
#[cfg(feature = "indexmap")]
mod indexmap_impl {
    use crate::{Context, DeepSizeOf};
    use core::mem::size_of;
    use indexmap::{IndexMap, IndexSet};

    // IndexMap uses a vec of buckets (usize, K, V) as backing, with
    // a hashbrown::RawTable<usize> for lookups.  This method will
    // consistently underestimate, because IndexMap::capacity will
    // return the min of the capacity of the buckets list and the
    // capacity of the raw table.
    impl<K, V, S> DeepSizeOf for IndexMap<K, V, S>
        where K: DeepSizeOf, V: DeepSizeOf
    {
        fn deep_size_of_children(&self, context: &mut Context) -> usize {
            let child_sizes = self.iter().fold(0, |sum, (key, val)| {
```

--------------------------------

### DeepSizeOf for Vec<T> Implementation

Source: https://docs.rs/deepsize/0.2.0/deepsize/trait.DeepSizeOf.html

Implementation of DeepSizeOf for `std::vec::Vec<T>`. It calculates the size of heap allocations for each child and adds the size of the Vec's own heap allocation based on its capacity.

```rust
impl<T> DeepSizeOf for std::vec::Vec<T> where T: DeepSizeOf {
    fn deep_size_of_children(&self, context: &mut Context) -> usize {
        // Size of heap allocations for each child
        self.iter().map(|child| child.deep_size_of_children(context)).sum()
         + self.capacity() * std::mem::size_of::<T>()  // Size of Vec's heap allocation
    }
}
```

--------------------------------

### Context Struct

Source: https://docs.rs/deepsize/0.2.0/deepsize/all.html

The Context struct is likely used internally by the deepsize crate for managing size calculation state.

```APIDOC
## Struct: Context

### Description
Represents the context for deep size calculations. Specific fields and methods are not detailed in the provided text.

### Fields
(Not specified in the provided text)

### Methods
(Not specified in the provided text)
```

--------------------------------

### DeepSizeOf Derive Macro

Source: https://docs.rs/deepsize/0.2.0/deepsize/derive.DeepSizeOf.html

Usage of the DeepSizeOf derive macro to implement size calculation for custom types.

```APIDOC
## Derive Macro: DeepSizeOf

### Description
The `DeepSizeOf` derive macro is used to automatically implement the `DeepSizeOf` trait for a given type. This allows the type to be used with the `deepsize` crate to calculate the total heap memory usage of a data structure.

### Usage
```rust
#[derive(DeepSizeOf)]
struct MyStruct {
    field1: String,
    field2: Vec<u8>,
}
```
```

--------------------------------

### Implement From<T> for T

Source: https://docs.rs/deepsize/0.2.0/deepsize/struct.Context.html

Blanket implementation of the `From` trait for converting a type `T` into itself. This is an identity conversion.

```rust
impl<T> From<T> for T
Source§
#### fn from(t: T) -> T
Returns the argument unchanged.
```

--------------------------------

### Implement TryInto<U> for T

Source: https://docs.rs/deepsize/0.2.0/deepsize/struct.Context.html

Blanket implementation of the `TryInto` trait for attempting to convert a type `T` into `U`. The conversion may fail, returning a `Result`.

```rust
impl<T, U> TryInto<U> for T
where U: TryFrom<T>,
Source§
#### type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
Source§
#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
Performs the conversion.
```

--------------------------------

### LinkedList DeepSizeOf Implementation

Source: https://docs.rs/deepsize/0.2.0/deepsize/trait.DeepSizeOf.html

Implementation of DeepSizeOf for LinkedList, accounting for node overhead.

```APIDOC
## impl<T> DeepSizeOf for LinkedList<T>

### Description
Sums the size of each child object in the LinkedList, assuming the overhead of each node is 2 usize (next, prev pointers).

### Request Example
```rust
use deepsize::DeepSizeOf;
use std::collections::LinkedList;

let mut list: LinkedList<u8> = LinkedList::new();
for i in 0..12 { list.push_back(i); }
list.push_front(13);

assert_eq!(list.deep_size_of(), std::mem::size_of::<LinkedList<u8>>() + 13 * 1 + 13 * 2 * 8);
```
```

--------------------------------

### Implement Into<U> for T

Source: https://docs.rs/deepsize/0.2.0/deepsize/struct.Context.html

Blanket implementation of the `Into` trait for converting a type `T` into another type `U`, provided that `U` implements `From<T>`. This enables type conversions.

```rust
impl<T, U> Into<U> for T
where U: From<T>,
Source§
#### fn into(self) -> U
Calls `U::from(self)`.
That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.
```

--------------------------------

### DeepSizeOf for chrono types

Source: https://docs.rs/deepsize/0.2.0/src/deepsize/external_impls.rs.html

Implements DeepSizeOf for various chrono types when the 'chrono' feature is enabled. This macro simplifies the implementation for multiple types.

```rust
mod chrono_impl {
    use crate::known_deep_size;
    use chrono::*;

    known_deep_size!(0;
        NaiveDate, NaiveTime, NaiveDateTime, IsoWeek,
        Duration, Month, Weekday,
        FixedOffset, Local, Utc,
        {T: TimeZone} DateTime<T>, {T: TimeZone} Date<T>,
    );
}
```

--------------------------------

### Implement TryFrom<U> for T

Source: https://docs.rs/deepsize/0.2.0/deepsize/struct.Context.html

Blanket implementation of the `TryFrom` trait for attempting to convert a type `U` into `T`. The conversion may fail, returning a `Result`.

```rust
impl<T, U> TryFrom<U> for T
where U: Into<T>,
Source§
#### type Error = Infallible
The type returned in the event of a conversion error.
Source§
#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
Performs the conversion.
```

--------------------------------

### Implement DeepSizeOf for Box

Source: https://docs.rs/deepsize/0.2.0/src/deepsize/lib.rs.html

Calculates the size of a boxed value by including the size of the value itself and its children.

```rust
impl<T> DeepSizeOf for alloc::boxed::Box<T>
where
    T: DeepSizeOf + ?Sized,
{
    fn deep_size_of_children(&self, context: &mut Context) -> usize {
        let val: &T = &*self;
        size_of_val(val) + val.deep_size_of_children(context)
    }
}
```

--------------------------------

### Define DeepSizeOf for Array Lengths

Source: https://docs.rs/deepsize/0.2.0/src/deepsize/default_impls.rs.html

This macro generates `impl DeepSizeOf` for arrays of specified lengths. It iterates through the array elements to calculate their deep size.

```Rust
macro_rules! deep_size_array {
    ($($num:expr,)+) => {
        deep_size_array!($($num),+);
    };
    ($($num:expr),+) => {
        $( 
            impl<T: DeepSizeOf> DeepSizeOf for [T; $num] {
                fn deep_size_of_children(&self, context: &mut Context) -> usize {
                    self.as_ref().deep_size_of_children(context)
                }
            }
        )+ 
    };
}
```

--------------------------------

### known_deep_size Macro Definition

Source: https://docs.rs/deepsize/0.2.0/deepsize/macro.known_deep_size.html

The macro definition syntax for specifying allocation sizes for types.

```rust
macro_rules! known_deep_size {
    ($size:expr; $($({$($gen:tt)*})? $type:ty,)+) => { ... };
    ($size:expr; $($({$($gen:tt)*})? $type:ty),+) => { ... };
}
```

--------------------------------

### Calculate Size of Vector with Allocated Objects

Source: https://docs.rs/deepsize/0.2.0/deepsize/trait.DeepSizeOf.html

Calculate the size of a vector containing heap-allocated objects like `Box<T>`. The size includes the vector's metadata, capacity, and the size of each allocated element.

```rust
use deepsize::DeepSizeOf;

let mut vec: Vec<Box<u64>> = vec![];
for i in 0..13 {
    vec.push(Box::new(i));
}

// The capacity (16?) * size (8) plus three usizes (len, cap, pointer)
// and length (13) * the allocated size of each object
assert_eq!(vec.deep_size_of(), 24 + vec.capacity() * 8 + 13 * 8);
```

--------------------------------

### Implement Borrow for T

Source: https://docs.rs/deepsize/0.2.0/deepsize/struct.Context.html

Blanket implementation of the `Borrow` trait for any type `T`. This allows immutable borrowing of a value as a reference to another type `T`.

```rust
impl<T> Borrow<T> for T
where T: ?Sized,
Source§
#### fn borrow(&self) -> &T
Immutably borrows from an owned value. Read more
```

--------------------------------

### Define DeepSizeOf for Tuples

Source: https://docs.rs/deepsize/0.2.0/src/deepsize/default_impls.rs.html

This macro generates `impl DeepSizeOf` for tuples of varying arities. It sums the deep size of each element within the tuple.

```Rust
macro_rules! deep_size_tuple {
    ($(($n:tt, $T:ident)),+ ) => {
        impl<$($T,)+> DeepSizeOf for ($($T,)+)
            where $($T: DeepSizeOf,)+
        {
            fn deep_size_of_children(&self, context: &mut Context) -> usize {
                0 $( + self.$n.deep_size_of_children(context))+
            }
        }
    };
}
```

--------------------------------

### Implement DeepSizeOf for Slices

Source: https://docs.rs/deepsize/0.2.0/src/deepsize/lib.rs.html

Sums the deep size of all elements contained within the slice.

```rust
impl<T> DeepSizeOf for [T]
where
    T: DeepSizeOf,
{
    fn deep_size_of_children(&self, context: &mut Context) -> usize {
        self.iter()
            .map(|child| child.deep_size_of_children(context))
            .sum()
    }
}
```

--------------------------------

### Measure deep size of a collection

Source: https://docs.rs/deepsize/0.2.0/src/deepsize/lib.rs.html

Calculate the total memory usage of a collection, including the size of its heap-allocated elements.

```rust
use deepsize::DeepSizeOf;

let mut map: Vec<(Box<u32>, String)> = Vec::new();

map.push((Box::new(42u32), String::from("Hello World")));
map.push((Box::new(20u32), String::from("Something")));
map.push((Box::new(0u32),  String::from("A string")));
map.push((Box::new(255u32), String::from("Dynamically Allocated!")));

assert_eq!(map.deep_size_of(),
    std::mem::size_of::<Vec<(Box<u32>, String)>>() +
    4 * std::mem::size_of::<(Box<u32>, String)>() +
    4 * std::mem::size_of::<u32>() +
    11 + 9 + 8 + 22
);
```

--------------------------------

### Implement BorrowMut for T

Source: https://docs.rs/deepsize/0.2.0/deepsize/struct.Context.html

Blanket implementation of the `BorrowMut` trait for any type `T`. This allows mutable borrowing of a value as a mutable reference to another type `T`.

```rust
impl<T> BorrowMut<T> for T
where T: ?Sized,
Source§
#### fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
```

--------------------------------

### DeepSizeOf Trait and Derive Macro

Source: https://docs.rs/deepsize/0.2.0/deepsize/all.html

The DeepSizeOf trait provides a method to calculate the deep size of a type. It can be derived using the DeepSizeOf derive macro.

```APIDOC
## Trait: DeepSizeOf

### Description
Provides a method to calculate the deep size of a type.

### Method
`deep_size_of()`

### Parameters
None

### Request Body
None

### Request Example
```rust
let my_struct = MyStruct { ... };
let size = my_struct.deep_size_of();
```

### Response
#### Success Response (usize)
- **size** (usize) - The deep size of the object in bytes.

#### Response Example
```
1024
```

## Derive Macro: DeepSizeOf

### Description
Automatically implements the `DeepSizeOf` trait for a struct or enum.

### Usage
```rust
#[derive(DeepSizeOf)]
struct MyStruct {
    field1: u32,
    field2: String,
}
```
```

--------------------------------

### Calculate Size of Vector with Primitive Types

Source: https://docs.rs/deepsize/0.2.0/deepsize/trait.DeepSizeOf.html

Use `deep_size_of` to calculate the size of a vector containing primitive types. This includes the vector's capacity and internal metadata.

```rust
use deepsize::DeepSizeOf;

let mut vec: Vec<u8> = vec![];
for i in 0..13 {
    vec.push(i);
}

// The capacity (16) plus three usizes (len, cap, pointer)
assert_eq!(vec.deep_size_of(), 16 + 24);
```

--------------------------------

### known_deep_size Macro

Source: https://docs.rs/deepsize/0.2.0/deepsize/all.html

The known_deep_size macro is likely used to assert or check the deep size of types at compile time or runtime.

```APIDOC
## Macro: known_deep_size

### Description
A macro likely used for asserting or verifying the known deep size of a type.

### Usage
(Specific usage and parameters not detailed in the provided text)

### Example
```rust
// Example usage (hypothetical)
// known_deep_size!(MyStruct, 1024);
```
```

--------------------------------

### Trait Method: deep_size_of

Source: https://docs.rs/deepsize/0.2.0/deepsize/trait.DeepSizeOf.html

Returns an estimation of the total size of memory owned by the object, including heap-managed storage.

```APIDOC
## fn deep_size_of(&self) -> usize

### Description
Returns an estimation of a total size of memory owned by the object, including heap-managed storage. This is the primary method to call when measuring an object's size.

### Response
- **usize** - The estimated total size in bytes.
```

--------------------------------

### Define Context Struct

Source: https://docs.rs/deepsize/0.2.0/deepsize/struct.Context.html

Defines the Context struct, which holds private fields for tracking visited references. This struct is primarily for internal use within the `deep_size_of_children` function to avoid redundant size calculations.

```rust
pub struct Context { /* private fields */ }
```
Tokens:
Raw