Enum disque_cli::Value [] [src]

pub enum Value {
    Null,
    NullArray,
    String(String),
    Error(String),
    Integer(i64),
    Bulk(String),
    BufBulk(Vec<u8>),
    Array(Vec<Value>),
}

Represents a RESP value, see Redis Protocol specification.

Variants

Null

Null bulk reply, $-1\r\n

NullArray

Null array reply, *-1\r\n

String(String)

For Simple Strings the first byte of the reply is "+".

Error(String)

For Errors the first byte of the reply is "-".

Integer(i64)

For Integers the first byte of the reply is ":".

Bulk(String)

For Bulk Strings the first byte of the reply is "$".

BufBulk(Vec<u8>)

For Bulk Strings the first byte of the reply is "$".

Array(Vec<Value>)

For Arrays the first byte of the reply is "*".

Methods

impl Value

fn is_null(&self) -> bool

Returns true if the value is a Null or NullArray. Returns false otherwise.

Examples

assert_eq!(Value::Null.is_null(), true);
assert_eq!(Value::NullArray.is_null(), true);
assert_eq!(Value::Integer(123).is_null(), false);

fn is_error(&self) -> bool

Returns true if the value is a Error. Returns false otherwise.

Examples

assert_eq!(Value::Null.is_error(), false);
assert_eq!(Value::Error("".to_string()).is_error(), true);

fn encode(&self) -> Vec<u8>

Encode the value to RESP binary buffer.

Examples

let val = Value::String("OK正".to_string());
assert_eq!(val.encode(), vec![43, 79, 75, 230, 173, 163, 13, 10]);

fn to_encoded_string(&self) -> Result<StringError>

Encode the value to RESP string.

Examples

let val = Value::String("OK正".to_string());
assert_eq!(val.to_encoded_string().unwrap(), "+OK正\r\n");

fn to_beautify_string(&self) -> String

Encode the value to beautify formated string.

Examples

assert_eq!(Value::Null.to_beautify_string(), "(Null)");
assert_eq!(Value::NullArray.to_beautify_string(), "(Null Array)");
assert_eq!(Value::String("OK".to_string()).to_beautify_string(), "OK");
assert_eq!(Value::Error("Err".to_string()).to_beautify_string(), "(Error) Err");
assert_eq!(Value::Integer(123).to_beautify_string(), "(Integer) 123");
assert_eq!(Value::Bulk("Bulk String".to_string()).to_beautify_string(), "\"Bulk String\"");
assert_eq!(Value::BufBulk(vec![]).to_beautify_string(), "(Empty Buffer)");
assert_eq!(Value::BufBulk(vec![0, 100]).to_beautify_string(), "(Buffer) 00 64");
assert_eq!(Value::Array(vec![]).to_beautify_string(), "(Empty Array)");

A full formated example:

 1) (Null)
 2) (Null Array)
 3) OK
 4) (Error) Err
 5) (Integer) 123
 6) \"Bulk String\"
 7) (Empty Array)
 8) (Buffer) 00 64
 9) 1) (Empty Array)
    2) (Integer) 123
    3) \"Bulk String\"
10) 1) (Null)
    2) (Null Array)
    3) OK
    4) (Error) Err
    5) (Integer) 123
    6) \"Bulk String\"
    7) (Empty Array)
    8) (Buffer) 00 64
    9) 1) (Empty Array)
       2) (Integer) 123
       3) \"Bulk String\"
11) (Null)
12) 1) (Null)
    2) (Null Array)
    3) OK
    4) (Error) Err
    5) (Integer) 123
    6) \"Bulk String\"
    7) (Empty Array)
    8) (Buffer) 00 64
    9) 1) (Empty Array)
       2) (Integer) 123
       3) \"Bulk String\"
   10) 1) (Null)
       2) (Null Array)
       3) OK
       4) (Error) Err
       5) (Integer) 123
       6) \"Bulk String\"
       7) (Empty Array)
       8) (Buffer) 00 64
       9) 1) (Empty Array)
          2) (Integer) 123
          3) \"Bulk String\"
   11) (Null)
13) (Null)

Trait Implementations

impl Debug for Value

fn fmt(&self, __arg_0: &mut Formatter) -> Result<()Error>

impl PartialEq<Value> for Value

fn eq(&self, __arg_0: &Value) -> bool

fn ne(&self, __arg_0: &Value) -> bool

impl Eq for Value

impl Clone for Value

fn clone(&self) -> Value

impl Sync for Value

impl Send for Value