pub unsafe fn put_current<A, B>(&mut self, key: A, data: B) -> Result<bool>
    where
        A: AsRef<[u8]>,
        B: AsRef<[u8]>,
    {
        self.cursor.put_current(key.as_ref(), data.as_ref())
    }
/// Write a new value to the current entry.
///
/// The given key **must** be equal to the one this cursor is pointing otherwise the database
/// can be put into an inconsistent state.
///
/// Returns `true` if the entry was successfully written.
///
/// > This is intended to be used when the new data is the same size as the old.
/// > Otherwise it will simply perform a delete of the old record followed by an insert.
///
/// # Safety
///
/// It is _[undefined behavior]_ to keep a reference of a value from this database while
/// modifying it, so you can't use the key/value that comes from the cursor to feed
/// this function.
///
/// In other words: Tranform the key and value that you borrow from this database into an owned
/// version of them i.e. `&str` into `String`.
///
/// > [Values returned from the database are valid only until a subsequent update operation,
/// or the end of the transaction.](http://www.lmdb.tech/doc/group__mdb.html#structMDB__val).
///
/// [undefined behavior]: https://doc.rust-lang.org/reference/behavior-considered-undefined.html
Write a new value to the current entry.
The given key **must** be equal to the one this cursor is pointing otherwise the database
can be put into an inconsistent state.

Returns `true` if the entry was successfully written.

> This is intended to be used when the new data is the same size as the old.
> Otherwise it will simply perform a delete of the old record followed by an insert.
Write a new value to the current entry . The given key ** must ** be equal to the one this cursor is pointing otherwise the database can be put into an inconsistent state . Returns ` true ` if the entry was successfully written . > This is intended to be used when the new data is the same size as the old . > Otherwise it will simply perform a delete of the old record followed by an insert .
pub unsafe fn put_current<A, B>(&mut self, key: A, data: B) -> Result<bool>
    where
        A: AsRef<[u8]>,
        B: AsRef<[u8]>,
    {
        self.cursor.put_current(key.as_ref(), data.as_ref())
    }
pub unsafe fn put_current < A , B > ( & mut self , key : A , data : B ) -> Result < bool > where A : AsRef < [ u8 ] > , B : AsRef < [ u8 ] > , { self . cursor . put_current ( key . as_ref ( ) , data . as_ref ( ) ) }
Write a new value to the current entry.
Write a new value to the current entry .
&mut self
key
A
data
B
&mut self
key
A
data
B
safety
It is _[undefined behavior]_ to keep a reference of a value from this database while
modifying it, so you can't use the key/value that comes from the cursor to feed
this function.

In other words: Tranform the key and value that you borrow from this database into an owned
version of them i.e. `&str` into `String`.

> [Values returned from the database are valid only until a subsequent update operation,
or the end of the transaction.].


It is _ [ undefined behavior ] _ to keep a reference of a value from this database while modifying it so you can ' t use the key / value that comes from the cursor to feed this function . In other words : Tranform the key and value that you borrow from this database into an owned version of them i . e . ` &str ` into ` String ` . > [ Values returned from the database are valid only until a subsequent update operation or the end of the transaction . ] .