icbiadb 0.2.3

IcbiaDB | I can't believe it's a database | Simple embedded KV & data structures database
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

use crate::decl::types::*;
use crate::types::bv::{BvObject};
use crate::storage::KvInterface;



pub struct Memory<KV: KvInterface<Key=Vec<u8>, Value=BvObject, RefKey=[u8]>> {
	/// KV storage
	kv_records: KV,
	/// Group declaration and storage
	decl_map: DeclarationMap,
	decl_records: DeclarationRecords,
}

impl<KV: KvInterface<Key=Vec<u8>, Value=BvObject, RefKey=[u8]>> Memory<KV> {
	pub fn new() -> Self {
		Memory {
			kv_records: KV::default(),
			decl_map: DeclarationMap::new(),
			decl_records: DeclarationRecords::new(),
		}
	}

	pub fn get(&self, key: &[u8]) -> &BvObject {
		self.kv_records.get(key)
	}

	pub fn get_mut(&mut self, key: &[u8]) -> &mut BvObject {
		self.kv_records.get_mut(key)
	}

	pub fn len(&self) -> usize {
		self.kv_records.len()
	}

	pub fn has_key(&self, key: &[u8]) -> bool {
		self.kv_records.has_key(key)
	}

	pub fn decl_get_mut(&mut self) -> &mut DeclarationMap {
		&mut self.decl_map
	}

	pub fn kv_records_get_mut(&mut self) -> &mut KV {
		&mut self.kv_records
	}

	pub fn decl_records_get_mut(&mut self) -> &mut DeclarationRecords {
		&mut self.decl_records
	}

	pub fn declaration_map(&self) -> &DeclarationMap {
		&self.decl_map
	}

	pub fn kv_records(&self) -> &KV {
		&self.kv_records
	}

	pub fn decl_records(&self) -> &DeclarationRecords {
		&self.decl_records
	}

	pub fn push_record(&mut self, r: (Vec<u8>, BvObject)) {
		self.kv_records.insert(r.0, r.1);
	}

	pub fn delete_record(&mut self, key: &[u8]) -> BvObject {
		self.kv_records.remove(key)
	}

	pub fn decls(&self) -> &DeclarationMap {
		&self.decl_map
	}

	pub fn insert_decl(&mut self, decl: &Declare) {
		self.decl_map.insert(decl.raw_name().to_vec(), decl.fields().to_owned());
		self.decl_records.insert(decl.raw_name().to_vec(), Vec::new());
	}

	pub fn remove_decl(&mut self, key: &[u8]) {
		self.decl_map.remove(key);
		self.decl_records.remove(key);
	}

	pub fn decl_insert_row(&mut self, name: Vec<u8>, record: DeclarationRecord) {
		let _field_rules = self.decl_map.get(name.as_slice());
		
		self.decl_records.entry(name)
			.and_modify(|v| v.push(record));
	}

	pub fn decl_insert_rows(&mut self, name: Vec<u8>, rows: Vec<DeclarationRecord>) {
		self.decl_records.entry(name)
			.and_modify(|v| v.extend(rows));
	}

	pub fn get_field_map(&self, name: &[u8]) -> &FieldMap {
		&self.decl_map[name]
	}

	pub fn get_decl_records(&self, name: &[u8]) -> &Vec<DeclarationRecord> {
		&self.decl_records.get(name).expect(&format!("No entry found for key {:?}", name.as_ref()))
	}

	pub fn get_decl_records_mut(&mut self, name: &[u8]) -> &mut Vec<DeclarationRecord> {
		self.decl_records.get_mut(name).expect(&format!("No entry found for key {:?}", name.as_ref()))
	}
}


impl<KV: KvInterface<Key=Vec<u8>, Value=BvObject, RefKey=[u8]>> std::ops::Index<&[u8]> for Memory<KV> {
	type Output = BvObject;

	fn index(&self, index: &[u8]) -> &Self::Output {
		self.kv_records.get(index)
	}
}

impl<KV: KvInterface<Key=Vec<u8>, Value=BvObject, RefKey=[u8]>> std::ops::IndexMut<&[u8]> for Memory<KV> {
	fn index_mut(&mut self, index: &[u8]) -> &mut Self::Output {
		self.kv_records.get_mut(index)
	}
}