unreql 0.2.1

Well documented and easy to use RethinkDB Rust Driver
Documentation 
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

use serde::Serialize;

use crate::{cmd::options::Index, Command};

use super::{Args, ArgsWithOpt, WithOpts};

/// Required first argument and optional second
///
/// Variants:
///
/// ```rust,ignore
/// // first required argument
/// r.example(arg);
///
/// // with both arguments as array of two elements
/// r.example(r.args([arg1, arg2]));
///
/// // with both arguments as tuple of two elements
/// r.example(r.args((arg1, arg2)));
///
/// // first required argument with command options
/// r.example(r.with_opt(arg, opt));
///
/// // with both arguments as array of two elements with command options
/// r.example(r.with_opt(r.args([arg1, arg2]), opt));
///
/// // with both arguments as tuple of two elements with command options
/// r.example(r.with_opt(r.args((arg1, arg2)), opt));
/// ```
pub trait OneAndSecondOptionalArg<P> {
    fn with_cmd(self, cmd: Command) -> Command;
}

impl<T, P> OneAndSecondOptionalArg<P> for T
where
    T: Serialize,
{
    fn with_cmd(self, cmd: Command) -> Command {
        cmd.with_arg(Command::from_json(self))
    }
}

impl<T, P> OneAndSecondOptionalArg<P> for Args<[T; 2]>
where
    T: Serialize,
{
    fn with_cmd(self, cmd: Command) -> Command {
        self.0
            .iter()
            .fold(cmd, |cmd, arg| cmd.with_arg(Command::from_json(arg)))
    }
}

impl<T1, T2, P> OneAndSecondOptionalArg<P> for Args<(T1, T2)>
where
    T1: Serialize,
    T2: Serialize,
{
    fn with_cmd(self, cmd: Command) -> Command {
        cmd.with_arg(Command::from_json(self.0 .0))
            .with_arg(Command::from_json(self.0 .1))
    }
}

impl<T, P> OneAndSecondOptionalArg<P> for ArgsWithOpt<T, P>
where
    T: Serialize,
    P: WithOpts,
{
    fn with_cmd(self, cmd: Command) -> Command {
        let cmd = cmd.with_arg(Command::from_json(self.0));
        self.1.with_opts(cmd)
    }
}

impl<T1, T2, P> OneAndSecondOptionalArg<P> for ArgsWithOpt<Args<(T1, T2)>, P>
where
    T1: Serialize,
    T2: Serialize,
    P: WithOpts,
{
    fn with_cmd(self, cmd: Command) -> Command {
        let cmd = cmd
            .with_arg(Command::from_json(self.0 .0 .0))
            .with_arg(Command::from_json(self.0 .0 .1));
        self.1.with_opts(cmd)
    }
}

impl<T, P> OneAndSecondOptionalArg<P> for ArgsWithOpt<Args<[T; 2]>, P>
where
    T: Serialize,
    P: WithOpts,
{
    fn with_cmd(self, cmd: Command) -> Command {
        let cmd = self
            .0
             .0
            .iter()
            .fold(cmd, |cmd, arg| cmd.with_arg(Command::from_json(arg)));
        self.1.with_opts(cmd)
    }
}

impl OneAndSecondOptionalArg<Index> for Index {
    fn with_cmd(self, cmd: Command) -> Command {
        self.with_opts(cmd)
    }
}