Struct assembly_data::fdb::sqlite::Connection [−][src]
pub struct Connection { /* fields omitted */ }
Expand description
A connection to a SQLite database.
Implementations
Set a busy handler that sleeps for a specified amount of time when a table is locked. The handler will sleep multiple times until at least “ms” milliseconds of sleeping have accumulated.
Calling this routine with an argument equal to zero turns off all busy handlers.
There can only be a single busy handler for a particular database
connection at any given moment. If another busy handler was defined
(using busy_handler
) prior to calling this routine, that other
busy handler is cleared.
Register a callback to handle SQLITE_BUSY
errors.
If the busy callback is None
, then SQLITE_BUSY is returned immediately upon encountering the lock.
The argument to the busy
handler callback is the number of times that the
busy handler has been invoked previously for the
same locking event. If the busy callback returns false
, then no
additional attempts are made to access the
database and SQLITE_BUSY
is returned to the
application. If the callback returns true
, then another attempt
is made to access the database and the cycle repeats.
There can only be a single busy handler defined for each database
connection. Setting a new busy handler clears any previously set
handler. Note that calling busy_timeout()
or evaluating PRAGMA busy_timeout=N
will change the busy handler and thus
clear any previously set busy handler.
Prepare a SQL statement for execution, returning a previously prepared
(but not currently in-use) statement if one is available. The
returned statement will be cached for reuse by future calls to
prepare_cached
once it is dropped.
fn insert_new_people(conn: &Connection) -> Result<()> {
{
let mut stmt = conn.prepare_cached("INSERT INTO People (name) VALUES (?)")?;
stmt.execute(&["Joe Smith"])?;
}
{
// This will return the same underlying SQLite statement handle without
// having to prepare it again.
let mut stmt = conn.prepare_cached("INSERT INTO People (name) VALUES (?)")?;
stmt.execute(&["Bob Jones"])?;
}
Ok(())
}
Failure
Will return Err
if sql
cannot be converted to a C-compatible string
or if the underlying SQLite call fails.
Set the maximum number of cached prepared statements this connection will hold. By default, a connection will hold a relatively small number of cached statements. If you need more, or know that you will not use cached statements, you can set the capacity manually using this method.
Remove/finalize all prepared statements currently in the cache.
Returns the current value of a config
.
- SQLITE_DBCONFIG_ENABLE_FKEY: return
false
ortrue
to indicate whether FK enforcement is off or on - SQLITE_DBCONFIG_ENABLE_TRIGGER: return
false
ortrue
to indicate whether triggers are disabled or enabled - SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER: return
false
ortrue
to indicate whether fts3_tokenizer are disabled or enabled - SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE: return
false
to indicate checkpoints-on-close are not disabled ortrue
if they are - SQLITE_DBCONFIG_ENABLE_QPSG: return
false
ortrue
to indicate whether the QPSG is disabled or enabled - SQLITE_DBCONFIG_TRIGGER_EQP: return
false
to indicate output-for-trigger are not disabled ortrue
if it is
Make configuration changes to a database connection
- SQLITE_DBCONFIG_ENABLE_FKEY:
false
to disable FK enforcement,true
to enable FK enforcement - SQLITE_DBCONFIG_ENABLE_TRIGGER:
false
to disable triggers,true
to enable triggers - SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER:
false
to disable fts3_tokenizer(),true
to enable fts3_tokenizer() - SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE:
false
(the default) to enable checkpoints-on-close,true
to disable them - SQLITE_DBCONFIG_ENABLE_QPSG:
false
to disable the QPSG,true
to enable QPSG - SQLITE_DBCONFIG_TRIGGER_EQP:
false
to disable output for trigger programs,true
to enable it
Query the current value of pragma_name
.
Some pragmas will return multiple rows/values which cannot be retrieved with this method.
Prefer PRAGMA function introduced in SQLite 3.20:
SELECT user_version FROM pragma_user_version;
Query the current rows/values of pragma_name
.
Prefer PRAGMA function introduced in SQLite 3.20:
SELECT * FROM pragma_collation_list;
Query the current value(s) of pragma_name
associated to
pragma_value
.
This method can be used with query-only pragmas which need an argument
(e.g. table_info('one_tbl')
) or pragmas which returns value(s)
(e.g. integrity_check
).
Prefer PRAGMA function introduced in SQLite 3.20:
SELECT * FROM pragma_table_info(?);
pub fn pragma_update(
&self,
schema_name: Option<DatabaseName<'_>>,
pragma_name: &str,
pragma_value: &dyn ToSql
) -> Result<(), Error>
pub fn pragma_update(
&self,
schema_name: Option<DatabaseName<'_>>,
pragma_name: &str,
pragma_value: &dyn ToSql
) -> Result<(), Error>
Set a new value to pragma_name
.
Some pragmas will return the updated value which cannot be retrieved with this method.
Set a new value to pragma_name
and return the updated value.
Only few pragmas automatically return the updated value.
Begin a new transaction with the default behavior (DEFERRED).
The transaction defaults to rolling back when it is dropped. If you
want the transaction to commit, you must call commit
or
set_drop_behavior(DropBehavior::Commit)
.
Example
fn perform_queries(conn: &mut Connection) -> Result<()> {
let tx = conn.transaction()?;
do_queries_part_1(&tx)?; // tx causes rollback if this fails
do_queries_part_2(&tx)?; // tx causes rollback if this fails
tx.commit()
}
Failure
Will return Err
if the underlying SQLite call fails.
pub fn transaction_with_behavior(
&mut self,
behavior: TransactionBehavior
) -> Result<Transaction<'_>, Error>
pub fn transaction_with_behavior(
&mut self,
behavior: TransactionBehavior
) -> Result<Transaction<'_>, Error>
Begin a new transaction with a specified behavior.
See transaction
.
Failure
Will return Err
if the underlying SQLite call fails.
Begin a new savepoint with the default behavior (DEFERRED).
The savepoint defaults to rolling back when it is dropped. If you want
the savepoint to commit, you must call commit
or
set_drop_behavior(DropBehavior::Commit)
.
Example
fn perform_queries(conn: &mut Connection) -> Result<()> {
let sp = conn.savepoint()?;
do_queries_part_1(&sp)?; // sp causes rollback if this fails
do_queries_part_2(&sp)?; // sp causes rollback if this fails
sp.commit()
}
Failure
Will return Err
if the underlying SQLite call fails.
Open a new connection to a SQLite database.
Connection::open(path)
is equivalent to
Connection::open_with_flags(path, OpenFlags::SQLITE_OPEN_READ_WRITE | OpenFlags::SQLITE_OPEN_CREATE)
.
fn open_my_db() -> Result<()> {
let path = "./my_db.db3";
let db = Connection::open(&path)?;
println!("{}", db.is_autocommit());
Ok(())
}
Failure
Will return Err
if path
cannot be converted to a C-compatible
string or if the underlying SQLite open call fails.
Open a new connection to an in-memory SQLite database.
Failure
Will return Err
if the underlying SQLite open call fails.
pub fn open_with_flags<P>(
path: P,
flags: OpenFlags
) -> Result<Connection, Error> where
P: AsRef<Path>,
pub fn open_with_flags<P>(
path: P,
flags: OpenFlags
) -> Result<Connection, Error> where
P: AsRef<Path>,
Open a new connection to a SQLite database.
Database Connection for a description of valid flag combinations.
Failure
Will return Err
if path
cannot be converted to a C-compatible
string or if the underlying SQLite open call fails.
Open a new connection to an in-memory SQLite database.
Database Connection for a description of valid flag combinations.
Failure
Will return Err
if the underlying SQLite open call fails.
Convenience method to run multiple SQL statements (that cannot take any parameters).
Uses sqlite3_exec under the hood.
Example
fn create_tables(conn: &Connection) -> Result<()> {
conn.execute_batch(
"BEGIN;
CREATE TABLE foo(x INTEGER);
CREATE TABLE bar(y TEXT);
COMMIT;",
)
}
Failure
Will return Err
if sql
cannot be converted to a C-compatible string
or if the underlying SQLite call fails.
pub fn execute<P>(&self, sql: &str, params: P) -> Result<usize, Error> where
P: IntoIterator,
<P as IntoIterator>::Item: ToSql,
pub fn execute<P>(&self, sql: &str, params: P) -> Result<usize, Error> where
P: IntoIterator,
<P as IntoIterator>::Item: ToSql,
Convenience method to prepare and execute a single SQL statement.
On success, returns the number of rows that were changed or inserted or
deleted (via sqlite3_changes
).
Example
fn update_rows(conn: &Connection) {
match conn.execute("UPDATE foo SET bar = 'baz' WHERE qux = ?", &[1i32]) {
Ok(updated) => println!("{} rows were updated", updated),
Err(err) => println!("update failed: {}", err),
}
}
Failure
Will return Err
if sql
cannot be converted to a C-compatible string
or if the underlying SQLite call fails.
Convenience method to prepare and execute a single SQL statement with named parameter(s).
On success, returns the number of rows that were changed or inserted or
deleted (via sqlite3_changes
).
Example
fn insert(conn: &Connection) -> Result<usize> {
conn.execute_named(
"INSERT INTO test (name) VALUES (:name)",
&[(":name", &"one")],
)
}
Failure
Will return Err
if sql
cannot be converted to a C-compatible string
or if the underlying SQLite call fails.
Get the SQLite rowid of the most recent successful INSERT.
Uses sqlite3_last_insert_rowid under the hood.
Convenience method to execute a query that is expected to return a single row.
Example
fn preferred_locale(conn: &Connection) -> Result<String> {
conn.query_row(
"SELECT value FROM preferences WHERE name='locale'",
NO_PARAMS,
|row| row.get(0),
)
}
If the query returns more than one row, all rows except the first are ignored.
Returns Err(QueryReturnedNoRows)
if no results are returned. If the
query truly is optional, you can call .optional()
on the result of
this to get a Result<Option<T>>
.
Failure
Will return Err
if sql
cannot be converted to a C-compatible string
or if the underlying SQLite call fails.
Convenience method to execute a query with named parameter(s) that is expected to return a single row.
If the query returns more than one row, all rows except the first are ignored.
Returns Err(QueryReturnedNoRows)
if no results are returned. If the
query truly is optional, you can call .optional()
on the result of
this to get a Result<Option<T>>
.
Failure
Will return Err
if sql
cannot be converted to a C-compatible string
or if the underlying SQLite call fails.
pub fn query_row_and_then<T, E, P, F>(
&self,
sql: &str,
params: P,
f: F
) -> Result<T, E> where
P: IntoIterator,
E: From<Error>,
F: FnOnce(&Row<'_>) -> Result<T, E>,
<P as IntoIterator>::Item: ToSql,
pub fn query_row_and_then<T, E, P, F>(
&self,
sql: &str,
params: P,
f: F
) -> Result<T, E> where
P: IntoIterator,
E: From<Error>,
F: FnOnce(&Row<'_>) -> Result<T, E>,
<P as IntoIterator>::Item: ToSql,
Convenience method to execute a query that is expected to return a
single row, and execute a mapping via f
on that returned row with
the possibility of failure. The Result
type of f
must implement
std::convert::From<Error>
.
Example
fn preferred_locale(conn: &Connection) -> Result<String> {
conn.query_row_and_then(
"SELECT value FROM preferences WHERE name='locale'",
NO_PARAMS,
|row| row.get(0),
)
}
If the query returns more than one row, all rows except the first are ignored.
Failure
Will return Err
if sql
cannot be converted to a C-compatible string
or if the underlying SQLite call fails.
Prepare a SQL statement for execution.
Example
fn insert_new_people(conn: &Connection) -> Result<()> {
let mut stmt = conn.prepare("INSERT INTO People (name) VALUES (?)")?;
stmt.execute(&["Joe Smith"])?;
stmt.execute(&["Bob Jones"])?;
Ok(())
}
Failure
Will return Err
if sql
cannot be converted to a C-compatible string
or if the underlying SQLite call fails.
Close the SQLite connection.
This is functionally equivalent to the Drop
implementation for
Connection
except that on failure, it returns an error and the
connection itself (presumably so closing can be attempted again).
Failure
Will return Err
if the underlying SQLite call fails.
Get access to the underlying SQLite database connection handle.
Warning
You should not need to use this function. If you do need to, please open an issue on the rusqlite repository and describe your use case.
Safety
This function is unsafe because it gives you raw access
to the SQLite connection, and what you do with it could impact the
safety of this Connection
.
Create a Connection
from a raw handle.
The underlying SQLite database connection handle will not be closed when the returned connection is dropped/closed.
Get access to a handle that can be used to interrupt long running queries from another thread.
Test for auto-commit mode. Autocommit mode is on by default.
Trait Implementations
Auto Trait Implementations
impl !RefUnwindSafe for Connection
impl !Sync for Connection
impl Unpin for Connection
impl UnwindSafe for Connection
Blanket Implementations
Mutably borrows from an owned value. Read more
fn fmt_binary(self) -> FmtBinary<Self> where
Self: Binary,
fn fmt_binary(self) -> FmtBinary<Self> where
Self: Binary,
Causes self
to use its Binary
implementation when Debug
-formatted.
fn fmt_display(self) -> FmtDisplay<Self> where
Self: Display,
fn fmt_display(self) -> FmtDisplay<Self> where
Self: Display,
Causes self
to use its Display
implementation when
Debug
-formatted. Read more
fn fmt_lower_exp(self) -> FmtLowerExp<Self> where
Self: LowerExp,
fn fmt_lower_exp(self) -> FmtLowerExp<Self> where
Self: LowerExp,
Causes self
to use its LowerExp
implementation when
Debug
-formatted. Read more
fn fmt_lower_hex(self) -> FmtLowerHex<Self> where
Self: LowerHex,
fn fmt_lower_hex(self) -> FmtLowerHex<Self> where
Self: LowerHex,
Causes self
to use its LowerHex
implementation when
Debug
-formatted. Read more
Causes self
to use its Octal
implementation when Debug
-formatted.
fn fmt_pointer(self) -> FmtPointer<Self> where
Self: Pointer,
fn fmt_pointer(self) -> FmtPointer<Self> where
Self: Pointer,
Causes self
to use its Pointer
implementation when
Debug
-formatted. Read more
fn fmt_upper_exp(self) -> FmtUpperExp<Self> where
Self: UpperExp,
fn fmt_upper_exp(self) -> FmtUpperExp<Self> where
Self: UpperExp,
Causes self
to use its UpperExp
implementation when
Debug
-formatted. Read more
fn fmt_upper_hex(self) -> FmtUpperHex<Self> where
Self: UpperHex,
fn fmt_upper_hex(self) -> FmtUpperHex<Self> where
Self: UpperHex,
Causes self
to use its UpperHex
implementation when
Debug
-formatted. Read more
impl<T> Pipe for T where
T: ?Sized,
impl<T> Pipe for T where
T: ?Sized,
Pipes by value. This is generally the method you want to use. Read more
Borrows self
and passes that borrow into the pipe function. Read more
fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R where
R: 'a,
fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R where
R: 'a,
Mutably borrows self
and passes that borrow into the pipe function. Read more
fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R where
Self: Borrow<B>,
R: 'a,
B: 'a + ?Sized,
fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R where
Self: Borrow<B>,
R: 'a,
B: 'a + ?Sized,
Borrows self
, then passes self.borrow()
into the pipe function. Read more
fn pipe_borrow_mut<'a, B, R>(
&'a mut self,
func: impl FnOnce(&'a mut B) -> R
) -> R where
Self: BorrowMut<B>,
R: 'a,
B: 'a + ?Sized,
fn pipe_borrow_mut<'a, B, R>(
&'a mut self,
func: impl FnOnce(&'a mut B) -> R
) -> R where
Self: BorrowMut<B>,
R: 'a,
B: 'a + ?Sized,
Mutably borrows self
, then passes self.borrow_mut()
into the pipe
function. Read more
fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R where
Self: AsRef<U>,
R: 'a,
U: 'a + ?Sized,
fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R where
Self: AsRef<U>,
R: 'a,
U: 'a + ?Sized,
Borrows self
, then passes self.as_ref()
into the pipe function.
fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R where
Self: AsMut<U>,
R: 'a,
U: 'a + ?Sized,
fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R where
Self: AsMut<U>,
R: 'a,
U: 'a + ?Sized,
Mutably borrows self
, then passes self.as_mut()
into the pipe
function. Read more
fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: Deref<Target = T>,
T: 'a + ?Sized,
R: 'a,
fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: Deref<Target = T>,
T: 'a + ?Sized,
R: 'a,
Borrows self
, then passes self.deref()
into the pipe function.
fn pipe_as_ref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: AsRef<T>,
T: 'a,
R: 'a,
fn pipe_as_ref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: AsRef<T>,
T: 'a,
R: 'a,
Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more
fn pipe_as_mut<'a, T, R>(&'a mut self, func: impl FnOnce(&'a mut T) -> R) -> R where
Self: AsMut<T>,
T: 'a,
R: 'a,
fn pipe_as_mut<'a, T, R>(&'a mut self, func: impl FnOnce(&'a mut T) -> R) -> R where
Self: AsMut<T>,
T: 'a,
R: 'a,
Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more
fn pipe_borrow<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: Borrow<T>,
T: 'a,
R: 'a,
fn pipe_borrow<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: Borrow<T>,
T: 'a,
R: 'a,
Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more
fn pipe_borrow_mut<'a, T, R>(
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: BorrowMut<T>,
T: 'a,
R: 'a,
fn pipe_borrow_mut<'a, T, R>(
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: BorrowMut<T>,
T: 'a,
R: 'a,
Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more
fn pipe_deref<'a, R>(&'a self, func: impl FnOnce(&'a Self::Target) -> R) -> R where
Self: Deref,
R: 'a,
fn pipe_deref<'a, R>(&'a self, func: impl FnOnce(&'a Self::Target) -> R) -> R where
Self: Deref,
R: 'a,
Pipes a dereference into a function that cannot normally be called in suffix position. Read more
fn pipe_deref_mut<'a, R>(
&'a mut self,
func: impl FnOnce(&'a mut Self::Target) -> R
) -> R where
Self: DerefMut,
R: 'a,
fn pipe_deref_mut<'a, R>(
&'a mut self,
func: impl FnOnce(&'a mut Self::Target) -> R
) -> R where
Self: DerefMut,
R: 'a,
Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more
Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more
fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self where
Self: Borrow<B>,
B: ?Sized,
fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self where
Self: Borrow<B>,
B: ?Sized,
Immutable access to the Borrow<B>
of a value. Read more
fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self where
Self: BorrowMut<B>,
B: ?Sized,
fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self where
Self: BorrowMut<B>,
B: ?Sized,
Mutable access to the BorrowMut<B>
of a value. Read more
Immutable access to the AsRef<R>
view of a value. Read more
fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self where
Self: AsMut<R>,
R: ?Sized,
fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self where
Self: AsMut<R>,
R: ?Sized,
Mutable access to the AsMut<R>
view of a value. Read more
Immutable access to the Deref::Target
of a value. Read more
Mutable access to the Deref::Target
of a value. Read more
Calls .tap()
only in debug builds, and is erased in release builds.
fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
Calls .tap_mut()
only in debug builds, and is erased in release
builds. Read more
fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self where
Self: Borrow<B>,
B: ?Sized,
fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self where
Self: Borrow<B>,
B: ?Sized,
Calls .tap_borrow()
only in debug builds, and is erased in release
builds. Read more
fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self where
Self: BorrowMut<B>,
B: ?Sized,
fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self where
Self: BorrowMut<B>,
B: ?Sized,
Calls .tap_borrow_mut()
only in debug builds, and is erased in release
builds. Read more
fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self where
Self: AsRef<R>,
R: ?Sized,
fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self where
Self: AsRef<R>,
R: ?Sized,
Calls .tap_ref()
only in debug builds, and is erased in release
builds. Read more
fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self where
Self: AsMut<R>,
R: ?Sized,
fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self where
Self: AsMut<R>,
R: ?Sized,
Calls .tap_ref_mut()
only in debug builds, and is erased in release
builds. Read more
Provides immutable access for inspection. Read more
Calls tap
in debug builds, and does nothing in release builds.
Provides mutable access for modification. Read more
fn tap_mut_dbg<F, R>(self, func: F) -> Self where
F: FnOnce(&mut Self) -> R,
fn tap_mut_dbg<F, R>(self, func: F) -> Self where
F: FnOnce(&mut Self) -> R,
Calls tap_mut
in debug builds, and does nothing in release builds.
impl<T, U> TapAsRef<U> for T where
U: ?Sized,
impl<T, U> TapAsRef<U> for T where
U: ?Sized,
Provides immutable access to the reference for inspection.
fn tap_ref_dbg<F, R>(self, func: F) -> Self where
Self: AsRef<T>,
F: FnOnce(&T) -> R,
fn tap_ref_dbg<F, R>(self, func: F) -> Self where
Self: AsRef<T>,
F: FnOnce(&T) -> R,
Calls tap_ref
in debug builds, and does nothing in release builds.
fn tap_ref_mut<F, R>(self, func: F) -> Self where
Self: AsMut<T>,
F: FnOnce(&mut T) -> R,
fn tap_ref_mut<F, R>(self, func: F) -> Self where
Self: AsMut<T>,
F: FnOnce(&mut T) -> R,
Provides mutable access to the reference for modification.
fn tap_ref_mut_dbg<F, R>(self, func: F) -> Self where
Self: AsMut<T>,
F: FnOnce(&mut T) -> R,
fn tap_ref_mut_dbg<F, R>(self, func: F) -> Self where
Self: AsMut<T>,
F: FnOnce(&mut T) -> R,
Calls tap_ref_mut
in debug builds, and does nothing in release builds.
impl<T, U> TapBorrow<U> for T where
U: ?Sized,
impl<T, U> TapBorrow<U> for T where
U: ?Sized,
fn tap_borrow<F, R>(self, func: F) -> Self where
Self: Borrow<T>,
F: FnOnce(&T) -> R,
fn tap_borrow<F, R>(self, func: F) -> Self where
Self: Borrow<T>,
F: FnOnce(&T) -> R,
Provides immutable access to the borrow for inspection. Read more
fn tap_borrow_dbg<F, R>(self, func: F) -> Self where
Self: Borrow<T>,
F: FnOnce(&T) -> R,
fn tap_borrow_dbg<F, R>(self, func: F) -> Self where
Self: Borrow<T>,
F: FnOnce(&T) -> R,
Calls tap_borrow
in debug builds, and does nothing in release builds.
fn tap_borrow_mut<F, R>(self, func: F) -> Self where
Self: BorrowMut<T>,
F: FnOnce(&mut T) -> R,
fn tap_borrow_mut<F, R>(self, func: F) -> Self where
Self: BorrowMut<T>,
F: FnOnce(&mut T) -> R,
Provides mutable access to the borrow for modification.
fn tap_borrow_mut_dbg<F, R>(self, func: F) -> Self where
Self: BorrowMut<T>,
F: FnOnce(&mut T) -> R,
fn tap_borrow_mut_dbg<F, R>(self, func: F) -> Self where
Self: BorrowMut<T>,
F: FnOnce(&mut T) -> R,
Calls tap_borrow_mut
in debug builds, and does nothing in release
builds. Read more
Immutably dereferences self
for inspection.
fn tap_deref_dbg<F, R>(self, func: F) -> Self where
Self: Deref,
F: FnOnce(&Self::Target) -> R,
fn tap_deref_dbg<F, R>(self, func: F) -> Self where
Self: Deref,
F: FnOnce(&Self::Target) -> R,
Calls tap_deref
in debug builds, and does nothing in release builds.
fn tap_deref_mut<F, R>(self, func: F) -> Self where
Self: DerefMut,
F: FnOnce(&mut Self::Target) -> R,
fn tap_deref_mut<F, R>(self, func: F) -> Self where
Self: DerefMut,
F: FnOnce(&mut Self::Target) -> R,
Mutably dereferences self
for modification.
fn tap_deref_mut_dbg<F, R>(self, func: F) -> Self where
Self: DerefMut,
F: FnOnce(&mut Self::Target) -> R,
fn tap_deref_mut_dbg<F, R>(self, func: F) -> Self where
Self: DerefMut,
F: FnOnce(&mut Self::Target) -> R,
Calls tap_deref_mut
in debug builds, and does nothing in release
builds. Read more