collectivity 3.2.2

Generic collection traits
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
128
129
130
131
132
133
134

use crate::{Safe, SafetyMarker, Unsafe};
#[cfg(feature = "std")]
use std::collections::{BinaryHeap, LinkedList, VecDeque};

/// Provides the ability to add a specified value to a collection.
///
/// The exact semantics of the push behavior may differ among collections, but the value is guaranteed to be inserted without overwriting previously inserted items.
///
/// ## Examples
/// ```
/// use std::collections::LinkedList;
/// use collectivity::{Get, Push};
///
/// fn push(
///   col: &mut impl Push<i32>,
///   v: i32
/// ) {
///   col.push(v);
/// }
///
/// let mut v = vec![];
/// push(&mut v, 0);
/// assert_eq!(v[0], 0);
///
/// let mut l = LinkedList::new();
/// push(&mut l, 0);
/// assert_eq!(l.get(0), Some(&0));
/// ```
pub trait Push<V> {
  /// Indicates whether the `push` method may panic in a particular implementation.
  type Safety: SafetyMarker = Unsafe;
  /// Adds the provided value to the collection.
  ///
  /// # Panics
  ///
  /// May panic, typically when the maximum collection size is exceeded.
  fn push(&mut self, v: V);
}

impl<'p, V, P: Push<V>> Push<V> for &'p mut P {
  fn push<'a>(&'a mut self, v: V) {
    <P as Push<V>>::push(self, v)
  }
}
impl<V> Push<V> for Vec<V> {
  fn push(&mut self, v: V) {
    self.push(v)
  }
}

#[cfg(feature = "std")]
impl<V> Push<V> for VecDeque<V> {
  fn push(&mut self, v: V) {
    VecDeque::push_back(self, v)
  }
}

#[cfg(feature = "std")]
impl<V: Ord> Push<V> for BinaryHeap<V> {
  type Safety = Safe;
  fn push(&mut self, v: V) {
    BinaryHeap::push(self, v)
  }
}

#[cfg(feature = "std")]
impl<V> Push<V> for LinkedList<V> {
  type Safety = Safe;
  fn push(&mut self, v: V) {
    self.push_back(v)
  }
}

#[cfg(feature = "serde_json")]
use serde_json::Value as SeV;

#[cfg(feature = "serde_json")]
impl Push<SeV> for SeV {
  fn push(&mut self, v: SeV) {
    match self {
      SeV::Array(o) => {
        o.push(v);
      }
      _ => panic!("Value is not an array"),
    }
  }
}

#[cfg(feature = "simd-json")]
use simd_json::{BorrowedValue as SBV, OwnedValue as SOV};

#[cfg(feature = "simd-json")]
impl<'a> Push<SBV<'a>> for SBV<'a> {
  fn push(&mut self, v: SBV<'a>) {
    match self {
      SBV::Array(a) => {
        a.push(v);
      }
      _ => panic!("Value is not an array"),
    }
  }
}

#[cfg(feature = "simd-json")]
impl Push<SOV> for SOV {
  fn push(&mut self, v: SOV) {
    match self {
      SOV::Array(a) => {
        a.push(v);
      }
      _ => panic!("Value is not an array"),
    }
  }
}

#[cfg(feature = "slab")]
use slab::Slab;

#[cfg(feature = "slab")]
impl<V> Push<V> for Slab<V> {
  fn push(&mut self, v: V) {
    self.insert(v);
  }
}

#[cfg(feature = "smallvec")]
use smallvec::{Array, SmallVec};

#[cfg(feature = "smallvec")]
impl<V, A: Array<Item = V>> Push<V> for SmallVec<A> {
  fn push(&mut self, v: V) {
    self.push(v)
  }
}