Don't leak arena implementation details into documentation

Signed-off-by: Victor Porof <victor.porof@gmail.com>

src/backend.rs

@@ -24,7 +24,7 @@ pub use impl_lmdb::RoCursorImpl as LmdbRoCursor;
 pub use impl_lmdb::RoTransactionImpl as LmdbRoTransaction;
 pub use impl_lmdb::RwTransactionImpl as LmdbRwTransaction;
 
-pub use impl_safe::DatabaseId as SafeModeDatabase;
+pub use impl_safe::DatabaseImpl as SafeModeDatabase;
 pub use impl_safe::EnvironmentBuilderImpl as SafeMode;
 pub use impl_safe::EnvironmentImpl as SafeModeEnvironment;
 pub use impl_safe::ErrorImpl as SafeModeError;

src/backend/impl_safe.rs

@@ -23,7 +23,7 @@ pub use cursor::{
     RoCursorImpl,
     RwCursorImpl,
 };
-pub use database::DatabaseId;
+pub use database::DatabaseImpl;
 pub use environment::{
     EnvironmentBuilderImpl,
     EnvironmentImpl,

src/backend/impl_safe/database.rs

@@ -18,18 +18,19 @@ use super::snapshot::Snapshot;
 use super::DatabaseFlagsImpl;
 use crate::backend::traits::BackendDatabase;
 
-pub type DatabaseId = Id<DatabaseImpl>;
+#[derive(Debug, Eq, PartialEq, Copy, Clone, Hash)]
+pub struct DatabaseImpl(pub(crate) Id<Database>);
 
-impl BackendDatabase for DatabaseId {}
+impl BackendDatabase for DatabaseImpl {}
 
 #[derive(Debug, Serialize, Deserialize)]
-pub struct DatabaseImpl {
+pub struct Database {
     snapshot: Snapshot,
 }
 
-impl DatabaseImpl {
-    pub(crate) fn new(flags: Option<DatabaseFlagsImpl>, snapshot: Option<Snapshot>) -> DatabaseImpl {
-        DatabaseImpl {
+impl Database {
+    pub(crate) fn new(flags: Option<DatabaseFlagsImpl>, snapshot: Option<Snapshot>) -> Database {
+        Database {
             snapshot: snapshot.unwrap_or_else(|| Snapshot::new(flags)),
         }
     }

src/backend/impl_safe/environment.rs

@@ -26,9 +26,9 @@ use id_arena::Arena;
 use log::warn;
 
 use super::{
-    database::DatabaseImpl,
+    database::Database,
     DatabaseFlagsImpl,
-    DatabaseId,
+    DatabaseImpl,
     EnvironmentFlagsImpl,
     ErrorImpl,
     InfoImpl,
@@ -43,8 +43,8 @@ use crate::backend::traits::{
 
 const DEFAULT_DB_FILENAME: &str = "data.safe.bin";
 
-type DatabaseArena = Arena<DatabaseImpl>;
-type DatabaseNameMap = HashMap<Option<String>, DatabaseId>;
+type DatabaseArena = Arena<Database>;
+type DatabaseNameMap = HashMap<Option<String>, DatabaseImpl>;
 
 #[derive(Debug, PartialEq, Eq, Copy, Clone)]
 pub struct EnvironmentBuilderImpl {
@@ -112,7 +112,7 @@ impl EnvironmentImpl {
     fn serialize(&self) -> Result<Vec<u8>, ErrorImpl> {
         let arena = self.arena.read().map_err(|_| ErrorImpl::DbPoisonError)?;
         let dbs = self.dbs.read().map_err(|_| ErrorImpl::DbPoisonError)?;
-        let data: HashMap<_, _> = dbs.iter().map(|(name, id)| (name, &arena[*id])).collect();
+        let data: HashMap<_, _> = dbs.iter().map(|(name, id)| (name, &arena[id.0])).collect();
         Ok(bincode::serialize(&data)?)
     }
 
@@ -121,7 +121,7 @@ impl EnvironmentImpl {
         let mut dbs = HashMap::new();
         let data: HashMap<_, _> = bincode::deserialize(&bytes)?;
         for (name, db) in data {
-            dbs.insert(name, arena.alloc(db));
+            dbs.insert(name, DatabaseImpl(arena.alloc(db)));
         }
         Ok((arena, dbs))
     }
@@ -189,7 +189,7 @@ impl EnvironmentImpl {
 
 impl<'e> BackendEnvironment<'e> for EnvironmentImpl {
     type Error = ErrorImpl;
-    type Database = DatabaseId;
+    type Database = DatabaseImpl;
     type Flags = DatabaseFlagsImpl;
     type Stat = StatImpl;
     type Info = InfoImpl;
@@ -218,7 +218,7 @@ impl<'e> BackendEnvironment<'e> for EnvironmentImpl {
         if dbs.keys().filter_map(|k| k.as_ref()).count() >= self.max_dbs {
             return Err(ErrorImpl::DbsFull);
         }
-        let id = dbs.entry(key).or_insert_with(|| arena.alloc(DatabaseImpl::new(Some(flags), None)));
+        let id = dbs.entry(key).or_insert_with(|| DatabaseImpl(arena.alloc(Database::new(Some(flags), None))));
         Ok(*id)
     }
 

src/backend/impl_safe/transaction.rs

@@ -13,7 +13,7 @@ use std::sync::Arc;
 
 use super::{
     snapshot::Snapshot,
-    DatabaseId,
+    DatabaseImpl,
     EnvironmentImpl,
     ErrorImpl,
     RoCursorImpl,
@@ -29,13 +29,13 @@ use crate::backend::traits::{
 #[derive(Debug)]
 pub struct RoTransactionImpl<'t> {
     env: &'t EnvironmentImpl,
-    snapshots: HashMap<DatabaseId, Snapshot>,
+    snapshots: HashMap<DatabaseImpl, Snapshot>,
     idx: Arc<()>,
 }
 
 impl<'t> RoTransactionImpl<'t> {
     pub(crate) fn new(env: &'t EnvironmentImpl, idx: Arc<()>) -> Result<RoTransactionImpl<'t>, ErrorImpl> {
-        let snapshots = env.dbs()?.iter().map(|(id, db)| (id, db.snapshot())).collect();
+        let snapshots = env.dbs()?.iter().map(|(id, db)| (DatabaseImpl(id), db.snapshot())).collect();
         Ok(RoTransactionImpl {
             env,
             snapshots,
@@ -46,7 +46,7 @@ impl<'t> RoTransactionImpl<'t> {
 
 impl<'t> BackendRoTransaction for RoTransactionImpl<'t> {
     type Error = ErrorImpl;
-    type Database = DatabaseId;
+    type Database = DatabaseImpl;
 
     fn get(&self, db: &Self::Database, key: &[u8]) -> Result<&[u8], Self::Error> {
         let snapshot = self.snapshots.get(db).ok_or_else(|| ErrorImpl::DbIsForeignError)?;
@@ -70,13 +70,13 @@ impl<'t> BackendRoCursorTransaction<'t> for RoTransactionImpl<'t> {
 #[derive(Debug)]
 pub struct RwTransactionImpl<'t> {
     env: &'t EnvironmentImpl,
-    snapshots: HashMap<DatabaseId, Snapshot>,
+    snapshots: HashMap<DatabaseImpl, Snapshot>,
     idx: Arc<()>,
 }
 
 impl<'t> RwTransactionImpl<'t> {
     pub(crate) fn new(env: &'t EnvironmentImpl, idx: Arc<()>) -> Result<RwTransactionImpl<'t>, ErrorImpl> {
-        let snapshots = env.dbs()?.iter().map(|(id, db)| (id, db.snapshot())).collect();
+        let snapshots = env.dbs()?.iter().map(|(id, db)| (DatabaseImpl(id), db.snapshot())).collect();
         Ok(RwTransactionImpl {
             env,
             snapshots,
@@ -87,7 +87,7 @@ impl<'t> RwTransactionImpl<'t> {
 
 impl<'t> BackendRwTransaction for RwTransactionImpl<'t> {
     type Error = ErrorImpl;
-    type Database = DatabaseId;
+    type Database = DatabaseImpl;
     type Flags = WriteFlagsImpl;
 
     fn get(&self, db: &Self::Database, key: &[u8]) -> Result<&[u8], Self::Error> {
@@ -142,7 +142,7 @@ impl<'t> BackendRwTransaction for RwTransactionImpl<'t> {
         let mut dbs = self.env.dbs_mut()?;
 
         for (id, snapshot) in self.snapshots {
-            let db = dbs.get_mut(id).ok_or_else(|| ErrorImpl::DbIsForeignError)?;
+            let db = dbs.get_mut(id.0).ok_or_else(|| ErrorImpl::DbIsForeignError)?;
             db.replace(snapshot);
         }