unobtanium 3.0.0

Opinioated Web search engine library with crawler and viewer companion.
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

use rusqlite::Connection;

use std::path::Path;
use std::sync::Arc;
use std::sync::RwLock;

use crate::database::Database;
use crate::database::DatabaseError;
use crate::database::DatabaseOpeningError;
use crate::database::DatabaseTransaction;
use crate::database::id_cache::EntityGenerationUuidCache;

pub struct SummaryDatabaseCache {
	pub entity_generation_id: Arc<RwLock<EntityGenerationUuidCache>>,
}

pub struct SummaryDatabase {
	base_db: Database,
	pub cache: SummaryDatabaseCache,
}

pub struct SummaryDatabaseTransaction<'a> {
	pub base_transaction: DatabaseTransaction<'a>,
	pub cache: &'a mut SummaryDatabaseCache,
}

impl SummaryDatabase {
	/// Initalize from a base database.
	pub fn initalize_from_base(db: Database) -> Result<Self, DatabaseError> {
		let summary_db = Self {
			base_db: db,
			cache: Default::default()
		};
		summary_db.initalize_summary_database()?;
		Ok(summary_db)
	}

	pub fn open_writable(
		path: impl AsRef<Path>
	) -> Result<Self, DatabaseOpeningError> {
		let database = Database::open_writable(&path)?;
		Self::initalize_from_base(database)
			.map_err(|e| e.while_initlizing(path))
	}

	pub fn open_read_only(
		path: impl AsRef<Path>
	) -> Result<Self, DatabaseOpeningError> {
		let database = Database::open_read_only(&path)?;
		Ok(Self {
			base_db: database,
			cache: Default::default()
		})
	}
	
	/// Grants access read only to the  base database.
	pub fn base(&self) -> &Database {
		&self.base_db
	}

	/// Grants mutable access to the uderlying base database.
	pub fn base_mut(&mut self) -> &mut Database {
		&mut self.base_db
	}

	/// Starts a database transaction and returns a handle for it.
	pub fn start_transaction(
		&mut self
	) -> Result<SummaryDatabaseTransaction, DatabaseError> {
		return Ok(SummaryDatabaseTransaction{
			base_transaction: self.base_db.start_transaction()?,
			cache: &mut self.cache
		})
	}

	/// Returns a handle for the database connection.
	pub fn connection(&self) -> &Connection {
		&self.base_db.connection
	}

}

impl<'a> SummaryDatabaseTransaction<'a> {

	/// Returns a handle for the database connection.
	pub fn connection(&self) -> &Connection {
		&self.base_transaction.transaction
	}

	/// Commit changes made within this transaction to the database.
	pub fn commit(self) -> Result<(), DatabaseError> {
		return self.base_transaction.commit();
	}
}

impl Default for SummaryDatabaseCache {
	fn default() -> Self {
		Self {
			entity_generation_id:
				Arc::new(EntityGenerationUuidCache::new().into()),
		}
	}
}