variadic_arguments 0.1.2

Implements variadic arguments into Rust.
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

#[cfg(no_std)]
use alloc::boxed::Box;

use super::{
    discriminant::Discriminant,
    inlined::Inlined,
    VariantHandle
};

/// A raw alias for the contents inside an owned argument.
pub enum BoxedArgument
{
    /// The contents have been allocated.
    Allocated(Box<dyn VariantHandle>),
    /// The contents have been inlined.
    Inlined(Inlined)
}

impl BoxedArgument
{
    /// Acquires the inner pointer from an owned argument.
    ///
    /// # SAFETY
    /// The following must be guaranteed for defined behavior.
    ///  * The pointer must be owned.
    ///  * The pointer must point to an actual OwnedArgument.
    #[inline(always)]
    pub unsafe fn from_owned(store: *mut dyn VariantHandle,
                             discriminant: Discriminant) -> Self
    {
        debug_assert!(!store.is_null());

        // Safety:
        //
        // As long as the discriminant matches correctly,
        // the following are assumed to be said state.
        match discriminant
        {
            Discriminant::Inlined =>
            {
                let inlined = Inlined::from(store);

                Self::Inlined(inlined)
            }
            Discriminant::Allocated =>
            {
                let allocated = unsafe { Box::from_raw(store) };

                Self::Allocated(allocated)
            }
            _ => unreachable!()
        }
    }
}