Struct Database

pub struct Database<T: TreeVersion> {
    pub inner: Arc<Mutex<DatabaseImpl<T>>>,
}

Fields

inner: Arc<Mutex<DatabaseImpl<T>>>

Implementations

impl Database<V2>

pub fn with<F, R>(&self, fun: F) -> R

where F: FnOnce(&mut DatabaseImpl<V2>) -> R,

impl Database<V2>

pub fn create_with_dir(depth: u8, dir_name: Option<PathBuf>) -> Self

pub fn create(depth: u8) -> Self

pub fn create_with_token_owners(depth: u8) -> Self

pub fn set_token_owners(&mut self)

pub fn unset_token_owners(&mut self)

pub fn root_hash(&mut self) -> Fp

pub fn naccounts(&self) -> usize

pub fn create_checkpoint(&self, directory_name: String)

pub fn make_checkpoint(&self, directory_name: String)

pub fn clone_db(&self, directory_name: PathBuf) -> Self

pub fn get_cached_hash(&self, addr: &Address) -> Option<Fp>

pub fn set_cached_hash(&mut self, addr: &Address, hash: Fp)

pub fn empty_hash_at_height(&mut self, height: usize) -> Fp

pub fn invalidate_hashes(&mut self, account_index: AccountIndex)

pub fn transfert_hashes(&mut self, hashes: HashesMatrix)

pub fn has_token_owners(&self) -> bool

Trait Implementations

impl BaseLedger for Database<V2>

fn to_list(&self) -> Vec<Account>

list of accounts in the ledger

fn iter<F>(&self, fun: F)

where F: FnMut(&Account),

iterate over all indexes and accounts

fn fold<B, F>(&self, init: B, fun: F) -> B

where F: FnMut(B, &Account) -> B,

fold over accounts in the ledger, passing the Merkle address

fn fold_with_ignored_accounts<B, F>( &self, ignoreds: HashSet<AccountId>, init: B, fun: F, ) -> B

where F: FnMut(B, &Account) -> B,

the set of account_ids are ledger elements to skip during the fold, because they’re in a mask

fn fold_until<B, F>(&self, init: B, fun: F) -> B

where F: FnMut(B, &Account) -> ControlFlow<B, B>,

fold until fun returns ControlFlow::Stop

fn accounts(&self) -> HashSet<AccountId>

set of account ids associated with accounts

fn token_owner(&self, token_id: TokenId) -> Option<AccountId>

Get the account id that owns a token.

fn tokens(&self, public_key: CompressedPubKey) -> HashSet<TokenId>

Get all of the tokens for which a public key has accounts.

fn location_of_account(&self, account_id: &AccountId) -> Option<Address>

fn location_of_account_batch( &self, account_ids: &[AccountId], ) -> Vec<(AccountId, Option<Address>)>

fn get_or_create_account( &mut self, account_id: AccountId, account: Account, ) -> Result<GetOrCreated, DatabaseError>

This may return an error if the ledger is full.

fn close(&self)

the ledger should not be used after calling close

fn last_filled(&self) -> Option<Address>

for account locations in the ledger, the last (rightmost) filled location

fn get_uuid(&self) -> Uuid

fn get_directory(&self) -> Option<PathBuf>

return Some directory for ledgers that use a file system, else None

fn get_account_hash(&mut self, account_index: AccountIndex) -> Option<Fp>

fn get(&self, addr: Address) -> Option<Box<Account>>

fn get_batch(&self, addr: &[Address]) -> Vec<(Address, Option<Box<Account>>)>

fn set(&mut self, addr: Address, account: Box<Account>)

fn set_batch(&mut self, list: &[(Address, Box<Account>)])

fn get_at_index(&self, index: AccountIndex) -> Option<Box<Account>>

fn set_at_index( &mut self, index: AccountIndex, account: Box<Account>, ) -> Result<(), ()>

fn index_of_account(&self, account_id: AccountId) -> Option<AccountIndex>

fn merkle_root(&mut self) -> Fp

meant to be a fast operation: the root hash is stored, rather than calculated dynamically

fn merkle_path(&mut self, addr: Address) -> Vec<MerklePath>

fn merkle_path_at_index(&mut self, index: AccountIndex) -> Vec<MerklePath>

fn remove_accounts(&mut self, ids: &[AccountId])

fn detached_signal(&mut self)

Triggers when the ledger has been detached and should no longer be accessed.

fn depth(&self) -> u8

fn num_accounts(&self) -> usize

fn merkle_path_at_addr(&mut self, addr: Address) -> Vec<MerklePath>

fn get_inner_hash_at_addr(&mut self, addr: Address) -> Result<Fp, String>

fn set_inner_hash_at_addr(&mut self, addr: Address, hash: Fp) -> Result<(), ()>

fn set_all_accounts_rooted_at( &mut self, addr: Address, accounts: &[Box<Account>], ) -> Result<(), ()>

fn get_all_accounts_rooted_at( &self, addr: Address, ) -> Option<Vec<(Address, Box<Account>)>>

Get all of the accounts that are in a subtree of the underlying Merkle tree rooted at address. The accounts are ordered by their addresses.

fn make_space_for(&mut self, space: usize)

fn commit(&mut self)

Used on mask only, has no effect with other implementation Required for LedgerIntf on masks

fn set_batch_accounts(&mut self, list: &[(Address, Box<Account>)])

impl<T: Clone + TreeVersion> Clone for Database<T>

fn clone(&self) -> Database<T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug + TreeVersion> Debug for Database<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.