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

use core::borrow::Borrow;
use eosio::{AccountName, ReadError, ScopeName, Table, WriteError};

pub enum Payer {
    Same,
    New(AccountName),
}

/// Table Cursor
pub trait TableCursor<T>: IntoIterator
where
    T: Table,
{
    /// Read and deserialize the current table row
    ///
    /// # Errors
    ///
    /// Will return `Err` if there was an issue reading the stored value.
    fn get(&self) -> Result<T::Row, ReadError>;

    /// Erase the current row
    ///
    /// # Errors
    ///
    /// Will return `Err` if there was an issue reading the stored value. Stored
    /// values must be read in order to erase secondary indexes.
    fn erase(&self) -> Result<T::Row, ReadError>;

    /// Modify the current row
    ///
    /// # Errors
    ///
    /// Will return `Err` if there was an issue serializing the value.
    fn modify<I: Borrow<T::Row>>(
        &self,
        payer: Payer,
        item: I,
    ) -> Result<usize, WriteError>;
}

/// Table index
pub trait TableIndex<'a, K, T>
where
    T: Table + 'a,
{
    /// The kind of cursor this table index uses
    type Cursor: TableCursor<T> + 'a;
    /// Returns the account name of the smart contract
    fn code(&'a self) -> AccountName;
    /// Returns the table scope
    fn scope(&'a self) -> ScopeName;
    /// Returns a cursor pointing to the first row that matches a key
    fn lower_bound<N: Into<K>>(&'a self, key: N) -> Option<Self::Cursor>;
    /// Returns a cursor pointing to the last row that matches a key
    fn upper_bound<N: Into<K>>(&'a self, key: N) -> Option<Self::Cursor>;

    /// Inserts a new row into the table
    ///
    /// # Errors
    ///
    /// Will return `Err` if there was an issue serializing the value.
    fn emplace<I: Borrow<T::Row>>(
        &'a self,
        payer: AccountName,
        item: I,
    ) -> Result<(), WriteError>;

    fn find<N: Into<K>>(&'a self, key: N) -> Option<Self::Cursor>;

    /// Returns true if the table contains a row with the specified primary key
    #[inline]
    fn exists<N: Into<K>>(&'a self, key: N) -> bool {
        self.find(key).is_some()
    }
}

/// Table iterator
pub trait TableIterator: DoubleEndedIterator {}