ascent 0.6.0-alpha

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

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

impl<'a, T> RelIndexWrite for &'a 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<'a, T> RelFullIndexWrite for &'a 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<'a, T> CRelIndexWrite for &'a 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<'a, T> CRelFullIndexWrite for &'a 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<'a, T> RelIndexMerge for &'a 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(&self) -> usize {
      (**self).len()
   }
}

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) }
}

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()
   }
}