kasino 0.1.0

Framework for implementing sharded concurrent datastructures.
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

//! Useful components and helper traits for implementing the [`Collection`] trait.

use core::marker::PhantomData;

use crate::{Collection, Signature};

/// A method that takes a `T` by value and returns it on an error.
pub struct TryPushSignature<T>(PhantomData<T>);

impl<T> Signature for TryPushSignature<T> {
    type Error<'input, 'arm>
        = T
    where
        Self: 'arm;
    type Input<'a> = T;
    type Output<'input, 'arm>
        = ()
    where
        Self: 'arm;
}

/// A method that returns a `T` on success.
pub struct PopSignature<T>(PhantomData<T>);

impl<T> Signature for PopSignature<T> {
    type Error<'input, 'arm>
        = ()
    where
        Self: 'arm;
    type Input<'a> = ();
    type Output<'input, 'arm>
        = T
    where
        Self: 'arm;
}

/// A method that takes no arguments and returns unit values.
pub struct Unit;

impl Signature for Unit {
    type Error<'input, 'arm>
        = ()
    where
        Self: 'arm;
    type Input<'a> = ();
    type Output<'input, 'arm>
        = ()
    where
        Self: 'arm;
}

/// A collection which one pushes items to and pops items from
pub trait PushPopCollection {
    /// The type of item stored in this collection
    type Item;

    /// Pushes an item to the collection.
    ///
    /// Returns the item on an error.
    fn push(&self, item: Self::Item) -> Result<(), Self::Item>;
    /// Tries to pop an item from the collection.
    fn pop(&self) -> Option<Self::Item>;
    /// The length of the collection.
    fn len(&self) -> usize;
    /// The capacity of the collection
    fn capacity(&self) -> usize;
    /// Is the collection empty?
    #[inline]
    fn is_empty(&self) -> bool {
        self.len() == 0
    }
}

impl<Q> Collection for Q
where
    Q: PushPopCollection,
{
    type OfferSignature = TryPushSignature<Q::Item>;
    type PollSignature = PopSignature<Q::Item>;

    #[inline]
    fn offer<'input, 'arm>(
        &'arm self,
        item: <Self::OfferSignature as Signature>::Input<'input>,
    ) -> Result<
        <Self::OfferSignature as Signature>::Output<'input, 'arm>,
        <Self::OfferSignature as Signature>::Error<'input, 'arm>,
    > {
        self.push(item)
    }

    #[inline]
    fn poll<'input, 'arm>(
        &'arm self,
        _input: <Self::PollSignature as Signature>::Input<'input>,
    ) -> Result<
        <Self::PollSignature as Signature>::Output<'input, 'arm>,
        <Self::PollSignature as Signature>::Error<'input, 'arm>,
    > {
        self.pop().ok_or(())
    }

    #[inline]
    fn len(&self) -> usize {
        PushPopCollection::len(self)
    }

    #[inline]
    fn capacity(&self) -> usize {
        PushPopCollection::capacity(self)
    }

    #[inline]
    fn is_empty(&self) -> bool {
        PushPopCollection::is_empty(self)
    }
}