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
126
127
128
129
130

crate::ix!();

///------------------------
pub struct DBIterator<'a> {
    parent: Rc<DBWrapper>,
    piter:  &'a mut dyn leveldb::LevelDBIteratorInterface,
}

impl<'a> Drop for DBIterator<'a> {
    fn drop(&mut self) {
        todo!();
        /*
            delete piter;
        */
    }
}

impl<'a> DBIterator<'a> {

    /**
      | @param[in] _parent
      | 
      | Parent CDBWrapper instance.
      | ----------
      | @param[in] _piter
      | 
      | The original leveldb iterator.
      |
      */
    pub fn new(
        parent: &DBWrapper,
        piter:  *mut leveldb::LevelDBIterator) -> Self {
    
        todo!();
        /*
        : parent(_parent),
        : piter(_piter),
        */
    }
    
    pub fn seek<K>(&mut self, key: &K)  {

        let mut ss_key: DataStream = DataStream::new(SER_DISK.try_into().unwrap(), CLIENT_VERSION);

        ss_key.reserve(DBWRAPPER_PREALLOC_KEY_SIZE);
        ss_key.stream(&key);

        let sl_key: leveldb::Slice 
        = leveldb::Slice::from_ptr_len(ss_key.data() as *mut u8, ss_key.size());

        (*self.piter).seek(&sl_key);
    }
    
    pub fn get_key<K>(&mut self, key: &mut K) -> bool {
    
        let sl_key: leveldb::Slice = (*self.piter).key();

        let mut try_block = || -> TryBlockResult::<_,&'static str> {

            let slice = unsafe { 
                std::ptr::slice_from_raw_parts(
                    sl_key.data(), 
                    sl_key.size()
                ).as_ref().unwrap()
            };

            let mut ss_key: DataStream 
                = DataStream::new_with_slice(
                    slice, 
                    SER_DISK.try_into().unwrap(), 
                    CLIENT_VERSION
                );

            ss_key.stream_into(&mut *key);

            TryBlockResult::Success
        };

        match try_block() {
            TryBlockResult::Return(v)  => return v,
            TryBlockResult::Err(e)  => {
                return false;
            },

            TryBlockResult::Success => { }
            TryBlockResult::Break   => { }
        }

        true
    }
    
    pub fn get_value<V>(&mut self, value: &mut V) -> bool {
    
        let sl_value: leveldb::Slice = (*self.piter).value();

        todo!();
        /*
            try {
                DataStream ssValue(MakeUCharSpan(slValue), SER_DISK, CLIENT_VERSION);
                ssValue.Xor(dbwrapper_:GetObfuscateKey(parent));
                ssValue >> value;
            } catch (const std::exception&) {
                return false;
            }
        */

        true
    }
    
    pub fn get_value_size(&mut self) -> usize {
        
        (*self.piter).value().size()
    }

    pub fn valid(&self) -> bool {
        
        (*self.piter).valid()
    }
    
    pub fn seek_to_first(&mut self)  {
        
        (*self.piter).seek_to_first();
    }
    
    pub fn next(&mut self)  {
        
        (*self.piter).next();
    }
}