Enum Mapping 

pub enum Mapping {
    Associative(Associative),
    Error(Error),
    Execute(Execute),
    Standard(Standard),
    Empty(Empty),
}

Mapping is used in response::Result and Query::results()

Examples

Match your response::Result to a concrete Response

use rqlite_client::response::{self, Result};
use rqlite_client::{Mapping, Response};

// // for description of the data structure
// let response_result: Result =
//     Ok(Response::Query(response::query::Query {
//         results: vec![Mapping::Error(response::mapping::Error {
//             error: String::new(),
//         })],
//         sequence_number: None,
//         time: None,
//     }));

let response_result: Option<Result> = None;

if let Some(Ok(response_result)) = response_result {
    let query = response::Query::from(response_result);
    for result in query.results() {
        match result {
            Mapping::Error(err) => err.to_string(),
            _ => "no error".to_string(),
        };
    }
}

Convert Result to an own data struct

use rqlite_client::response::{self, Query, Result};
use rqlite_client::response::mapping::Timed;
use rqlite_client::{Mapping, Response};

struct MyData {
    timing: std::time::Duration,
}

impl TryFrom<&Mapping> for MyData {
    type Error = rqlite_client::Error;

    fn try_from(r: &Mapping) -> std::result::Result<Self, Self::Error> {
        match r {
            Mapping::Associative(r) => Ok(MyData {
                timing: r.duration().unwrap(),
            }),
            Mapping::Standard(r) => Ok(MyData {
                timing: r.duration().unwrap(),
            }),
            _ => Err(rqlite_client::Error::from("not expected MyData")),
        }
    }
}

let response_result: Option<Result> = None;

if let Some(Ok(response_result)) = response_result {
    let query = response::Query::from(response_result);
    let my_data = query
        .results()
        .filter_map(|r| MyData::try_from(r).ok())
        .collect::<Vec<MyData>>();
}

Variants

Associative(Associative)

See Associative

Error(Error)

See Error

Execute(Execute)

See Execute

Standard(Standard)

See Standard

Empty(Empty)

See Empty

Trait Implementations

impl Clone for Mapping

fn clone(&self) -> Mapping

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Mapping

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Mapping

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Mapping

fn eq(&self, other: &Mapping) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Mapping

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Mapping