ascent 0.8.0

Logic programming in 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
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

use crate::internal::{
   CRelFullIndexWrite, CRelIndexWrite, RelFullIndexRead, RelFullIndexWrite, RelIndexMerge, RelIndexWrite,
};
use crate::rel_index_read::{RelIndexRead, RelIndexReadAll};

impl<T> RelIndexWrite for &mut T
where T: RelIndexWrite
{
   type Key = T::Key;
   type Value = T::Value;

   #[inline(always)]
   fn index_insert(&mut self, key: Self::Key, value: Self::Value) { (**self).index_insert(key, value) }
}

impl<T> RelFullIndexWrite for &mut T
where T: RelFullIndexWrite
{
   type Key = T::Key;
   type Value = T::Value;

   #[inline(always)]
   fn insert_if_not_present(&mut self, key: &Self::Key, v: Self::Value) -> bool {
      (**self).insert_if_not_present(key, v)
   }
}

impl<T> CRelIndexWrite for &T
where T: CRelIndexWrite
{
   type Key = T::Key;
   type Value = T::Value;

   #[inline(always)]
   fn index_insert(&self, key: Self::Key, value: Self::Value) { (**self).index_insert(key, value) }
}

impl<T> CRelFullIndexWrite for &T
where T: CRelFullIndexWrite
{
   type Key = T::Key;
   type Value = T::Value;

   #[inline(always)]
   fn insert_if_not_present(&self, key: &Self::Key, v: Self::Value) -> bool { (**self).insert_if_not_present(key, v) }
}

impl<T> RelIndexMerge for &mut T
where T: RelIndexMerge
{
   fn move_index_contents(from: &mut Self, to: &mut Self) { T::move_index_contents(*from, *to) }

   fn merge_delta_to_total_new_to_delta(new: &mut Self, delta: &mut Self, total: &mut Self) {
      T::merge_delta_to_total_new_to_delta(*new, *delta, *total)
   }

   fn init(new: &mut Self, delta: &mut Self, total: &mut Self) { T::init(new, delta, total) }
}

impl<'a, T> RelIndexRead<'a> for &'a T
where T: RelIndexRead<'a>
{
   type Key = T::Key;
   type Value = T::Value;
   type IteratorType = T::IteratorType;

   #[inline(always)]
   fn index_get(&'a self, key: &Self::Key) -> Option<Self::IteratorType> { (**self).index_get(key) }

   #[inline(always)]
   fn len_estimate(&self) -> usize { (**self).len_estimate() }

   #[inline(always)]
   fn is_empty(&'a self) -> bool { (**self).is_empty() }
}

impl<'a, T> RelIndexReadAll<'a> for &'a T
where T: RelIndexReadAll<'a>
{
   type Key = T::Key;
   type Value = T::Value;
   type ValueIteratorType = T::ValueIteratorType;
   type AllIteratorType = T::AllIteratorType;

   #[inline(always)]
   fn iter_all(&'a self) -> Self::AllIteratorType { (**self).iter_all() }
}

impl<'a, T> RelFullIndexRead<'a> for &'a T
where T: RelFullIndexRead<'a>
{
   type Key = T::Key;
   #[inline(always)]
   fn contains_key(&self, key: &Self::Key) -> bool { (**self).contains_key(key) }
}

#[cfg(feature = "par")]
mod par {
   use crate::internal::{CRelIndexRead, CRelIndexReadAll};

   impl<'a, T> CRelIndexRead<'a> for &'a T
   where T: CRelIndexRead<'a>
   {
      type Key = T::Key;
      type Value = T::Value;
      type IteratorType = T::IteratorType;

      #[inline(always)]
      fn c_index_get(&'a self, key: &Self::Key) -> Option<Self::IteratorType> { (**self).c_index_get(key) }
   }

   impl<'a, T> CRelIndexReadAll<'a> for &'a T
   where T: CRelIndexReadAll<'a>
   {
      type Key = T::Key;
      type Value = T::Value;
      type ValueIteratorType = T::ValueIteratorType;
      type AllIteratorType = T::AllIteratorType;

      #[inline(always)]
      fn c_iter_all(&'a self) -> Self::AllIteratorType { (**self).c_iter_all() }
   }
}