struct_scalpel 0.1.1

memory layout analysis tool for structs, enums, unions, tuples, and references
Documentation 
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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

#![allow(dead_code)]

pub mod cell;
pub mod sync;

use dummy::*;

use std::cell::Cell;
use std::marker::PhantomData;
use std::ptr::NonNull;
use std::rc::Rc;
use std::{ptr::Unique};
use std::alloc::Allocator;

use crate::{impl_mirror_mock, Dissectible};

#[derive(Dissectible)]
struct MockString { 
    vec: Vec<u8>,
}
impl_mirror_mock!(MockString => String);

#[derive(Dissectible)]
enum MockOption<T> { 
    None, 
    Some(T), 
}
impl_mirror_mock!(with <T>: MockOption<T> => Option<T>);

#[derive(Dissectible)]
enum MockResult<T, E> { 
    Ok(T), 
    Err(E), 
}
impl_mirror_mock!(with <T, E>: MockResult<T, E> => Result<T, E>);

#[derive(Dissectible)]
struct MockVec<T, A> where A: Allocator{
    buf: RawVec<T, A>,
    len: usize
}
impl_mirror_mock!(with <T, A>: MockVec<T, A> => Vec<T, A> where A: Allocator);

#[derive(Dissectible)]
struct MockBox<T, A>(Unique<T>, A) where T: ?Sized;
impl_mirror_mock!(with <T, A>: MockBox<T, A> => Box<T, A> where T: ?Sized, A: Allocator);

#[repr(C)]
/// This is a dummy copy of the internal type RcBox<T>, used as a field in Rc<T>, which is shadowed by the public dummy::RcBox<T> and can be unsized
struct RcBox<T> where T: ?Sized {
    strong: Cell<usize>,
    weak: Cell<usize>,
    value: T,
}

#[derive(Dissectible)]
struct MockRc<T> where T: ?Sized{
    ptr: NonNull<RcBox<T>>,
    phantom: PhantomData<RcBox<T>>,
}
impl_mirror_mock!(with <T>: MockRc<T> => Rc<T> where T: ?Sized);

pub mod dummy {
    use std::{ptr::Unique, alloc::Allocator, cell::Cell};

    use crate::Dissectible;

    #[derive(Dissectible)]
    /// This is a dummy copy of the internal type RawVec<T, A>, used as a field in Vec<T, A>
    pub struct RawVec<T, A> where A: Allocator {
        ptr: Unique<T>,
        cap: usize,
        alloc: A,
    }

    #[derive(Dissectible)]
    #[repr(C)]
    /// This is a dummy copy of the internal type RcBox<T>, used as a field in Rc<T>
    pub struct RcBox<T> {
        strong: Cell<usize>,
        weak: Cell<usize>,
        value: T,
    }
}