dairy 0.2.2

A more compact, user friendly clone-on-write smart pointer.
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
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

//! A better `Cow` implementation.

mod convert;
mod extent;

use core::marker::PhantomData;
use core::mem::ManuallyDrop;
use core::ptr::NonNull;

use crate::imp;
use crate::imp::Cow as _;

use self::convert::{Convert, IsOwned};

/// A compact clone-on-write smart pointer.
pub struct Cow<'a, T>
where
    T: ?Sized + Convert,
{
    /// Pointer to the data.
    ptr: NonNull<T::Ptr>,

    /// Any extra data that is required to reconstruct an owned or borrowed
    /// variant of this type. For example: length and capacity.
    extent: T::Extent,

    /// For the lifetime.
    marker: PhantomData<&'a T>,
}

impl<'a, T> imp::Cow<'a, T> for Cow<'a, T>
where
    T: ?Sized + Convert,
{
    #[inline]
    fn borrowed(b: &'a T) -> Self {
        let (ptr, extent) = T::unmake_borrowed(b);
        Self {
            ptr,
            extent,
            marker: PhantomData,
        }
    }

    #[inline]
    fn owned(o: T::Owned) -> Self {
        let (ptr, extent) = T::unmake_owned(o);
        Self {
            ptr,
            extent,
            marker: PhantomData,
        }
    }

    #[inline]
    fn is_borrowed(&self) -> bool {
        !self.extent.is_owned()
    }

    #[inline]
    fn is_owned(&self) -> bool {
        self.extent.is_owned()
    }

    #[inline]
    fn make_ref(&self) -> &T {
        // SAFETY: This is valid for both owned and borrowed variants.
        unsafe { &*T::make_ptr(self.ptr, self.extent) }
    }

    #[inline]
    fn into_owned(self) -> T::Owned {
        if self.is_owned() {
            let cow = ManuallyDrop::new(self);
            unsafe { T::make_owned(cow.ptr, cow.extent) }
        } else {
            self.make_ref().to_owned()
        }
    }

    #[inline]
    fn apply<F>(&mut self, f: F)
    where
        F: FnOnce(&mut T::Owned),
    {
        let mut o = if self.is_owned() {
            // SAFETY:  This is safe because we temporarily set the `extent` to
            // its default value which should encode a "borrowed" version.
            // Therefore, if `f` had to panic, no double drop would occur.
            let o = unsafe { T::make_owned(self.ptr, self.extent) };
            self.extent = T::Extent::default();
            o
        } else {
            self.make_ref().to_owned()
        };
        f(&mut o);
        let (ptr, extent) = T::unmake_owned(o);
        self.ptr = ptr;
        self.extent = extent;
    }
}

impl<T> Clone for Cow<'_, T>
where
    T: ?Sized + Convert,
{
    #[inline]
    fn clone(&self) -> Self {
        if self.is_owned() {
            Self::owned(self.make_ref().to_owned())
        } else {
            Self { ..*self }
        }
    }
}

impl<T> Drop for Cow<'_, T>
where
    T: ?Sized + Convert,
{
    #[inline]
    fn drop(&mut self) {
        if self.is_owned() {
            unsafe { T::make_owned(self.ptr, self.extent) };
        }
    }
}