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

use crate::resp::BulkString;

#[derive(Debug)]
pub enum CommandArgs {
    Empty,
    Single(BulkString),
    Array2([BulkString; 2]),
    Array3([BulkString; 3]),
    Array4([BulkString; 4]),
    Vec(Vec<BulkString>),
}

impl CommandArgs {
    /// Return the first command
    pub(crate) fn first(&self) -> &BulkString {
        match self {
            CommandArgs::Empty => {
                unimplemented!("Cannot get first argument because arguments are empty")
            }
            CommandArgs::Single(s) => s,
            CommandArgs::Array2(a) => &a[0],
            CommandArgs::Array3(a) => &a[0],
            CommandArgs::Array4(a) => &a[0],
            CommandArgs::Vec(v) => &v[0],
        }
    }
}

impl CommandArgs {
    pub fn len(&self) -> usize {
        match self {
            CommandArgs::Empty => 0,
            CommandArgs::Single(_) => 1,
            CommandArgs::Array2(_) => 2,
            CommandArgs::Array3(_) => 3,
            CommandArgs::Array4(_) => 4,
            CommandArgs::Vec(v) => v.len(),
        }
    }
}

impl<T> From<T> for CommandArgs
where
    T: Into<BulkString>,
{
    fn from(arg: T) -> Self {
        CommandArgs::Single(arg.into())
    }
}

impl From<[BulkString; 2]> for CommandArgs {
    fn from(args: [BulkString; 2]) -> Self {
        CommandArgs::Array2(args)
    }
}

impl From<[BulkString; 3]> for CommandArgs {
    fn from(args: [BulkString; 3]) -> Self {
        CommandArgs::Array3(args)
    }
}

impl From<[BulkString; 4]> for CommandArgs {
    fn from(args: [BulkString; 4]) -> Self {
        CommandArgs::Array4(args)
    }
}

impl From<Vec<BulkString>> for CommandArgs {
    fn from(args: Vec<BulkString>) -> Self {
        CommandArgs::Vec(args)
    }
}