Value in redis - Rust
Description: Internal low-level redis value enum.

Skip to main content

## Value

# Enum Value

Source

    #[non_exhaustive]pub enum Value {
    Show 15 variants    Nil,
        Int(i64),
        BulkString(Vec<u8>),
        Array(Vec<Value>),
        SimpleString(String),
        Okay,
        Map(Vec<(Value, Value)>),
        Attribute {
            data: Box<Value>,
            attributes: Vec<(Value, Value)>,
        },
        Set(Vec<Value>),
        Double(f64),
        Boolean(bool),
        VerbatimString {
            format: VerbatimFormat,
            text: String,
        },
        BigNumber(BigInt),
        Push {
            kind: PushKind,
            data: Vec<Value>,
        },
        ServerError(ServerError),
    }

Expand description

Internal low-level redis value enum.

## Variants (Non-exhaustive)§

This enum is marked as non-exhaustive
Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.
§

### Nil

A nil response from the server.

§

### Int(i64)

An integer response. Note that there are a few situations in which redis actually returns a string for an integer which is why this library generally treats integers and strings the same for all numeric responses.

§

### BulkString(Vec<u8>)

An arbitrary binary data, usually represents a binary-safe string.

§

### Array(Vec<Value>)

A response containing an array with more data. This is generally used by redis to express nested structures.

§

### SimpleString(String)

A simple string response, without line breaks and not binary safe.

§

### Okay

A status response which represents the string “OK”.

§

### Map(Vec<(Value, Value)>)

Unordered key,value list from the server. Use `as_map_iter` function.

§

### Attribute

Attribute value from the server. Client will give data instead of whole Attribute type.

#### Fields

§`data: Box<Value>`

Data that attributes belong to.

§`attributes: Vec<(Value, Value)>`

Key,Value list of attributes.

§

### Set(Vec<Value>)

Unordered set value from the server.

§

### Double(f64)

A floating number response from the server.

§

### Boolean(bool)

A boolean response from the server.

§

### VerbatimString

First String is format and other is the string

#### Fields

§`format: VerbatimFormat`

Text’s format type

§`text: String`

Remaining string check format before using!

§

### BigNumber(BigInt)

Available on crate feature `num-bigint` only.

Very large number that out of the range of the signed 64 bit numbers

§

### Push

Push data from the server.

#### Fields

§`kind: PushKind`

Push Kind

§`data: Vec<Value>`

Remaining data from push message

§

### ServerError(ServerError)

Represents an error message from the server

## Implementations§

Source§

### impl Value

Values are generally not used directly unless you are using the more low level functionality in the library. For the most part this is hidden with the help of the `FromRedisValue` trait.

While on the redis protocol there is an error type this is already separated at an early point so the value only holds the remaining types.

Source

#### pub fn looks_like_cursor(&self) -> bool

Checks if the return value looks like it fulfils the cursor protocol. That means the result is an array item of length two with the first one being a cursor and the second an array response.

Source

#### pub fn as_sequence(&self) -> Option<&[Value]>

Returns an `&[Value]` if `self` is compatible with a sequence type

Source

#### pub fn into_sequence(self) -> Result<Vec<Value>, Value>

Returns a `Vec<Value>` if `self` is compatible with a sequence type, otherwise returns `Err(self)`.

Source

#### pub fn as_map_iter(&self) -> Option<MapIter<'_>>

Returns an iterator of `(&Value, &Value)` if `self` is compatible with a map type

Source

#### pub fn into_map_iter(self) -> Result<OwnedMapIter, Value>

Returns an iterator of `(Value, Value)` if `self` is compatible with a map type. If not, returns `Err(self)`.

Source

#### pub fn extract_error(self) -> RedisResult<Self>

If value contains a server error, return it as an Err. Otherwise wrap the value in Ok.

## Trait Implementations§

Source§

### impl Clone for Value

Source§

#### fn clone(&self) -> Value

Returns a duplicate of the value. Read more
1.0.0 · Source§

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

Performs copy-assignment from `source`. Read more
Source§

### impl Debug for Value

Source§

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

Formats the value using the given formatter. Read more
Source§

### impl Default for Value

Source§

#### fn default() -> Value

Returns the “default value” for a type. Read more
Source§

### impl FromRedisValue for Value

Source§

#### fn from_redis_value_ref(v: &Value) -> Result<Value, ParsingError>

Given a redis `Value` this attempts to convert it into the given destination type. If that fails because it’s not compatible an appropriate error is generated.
Source§

#### fn from_redis_value(v: Value) -> Result<Self, ParsingError>

Given a redis `Value` this attempts to convert it into the given destination type. If that fails because it’s not compatible an appropriate error is generated.
Source§

#### fn from_redis_value_refs(items: &[Value]) -> Result<Vec<Self>, ParsingError>

Similar to `from_redis_value_ref` but constructs a vector of objects from another vector of values. This primarily exists internally to customize the behavior for vectors of tuples.
Source§

#### fn from_redis_values(items: Vec<Value>) -> Result<Vec<Self>, ParsingError>

The same as `from_redis_value_refs`, but takes a `Vec<Value>` instead of a `&[Value]`.
Source§

#### fn from_each_redis_values(items: Vec<Value>) -> Vec<Result<Self, ParsingError>>

The same as `from_redis_values`, but returns a result for each conversion to make handling them case-by-case possible.
Source§

#### fn from_byte_slice(_vec: &[u8]) -> Option<Vec<Self>>

Convert bytes to a single element vector.
Source§

#### fn from_byte_vec(_vec: Vec<u8>) -> Result<Vec<Self>, ParsingError>

Convert bytes to a single element vector.
Source§

### impl PartialEq for Value

Source§

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

Tests for `self` and `other` values to be equal, and is used by `==`.
1.0.0 · Source§

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

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

### impl StructuralPartialEq for Value

## Auto Trait Implementations§

§

### impl Freeze for Value

§

### impl RefUnwindSafe for Value

§

### impl Send for Value

§

### impl Sync for Value

§

### impl Unpin for Value

§

### impl UnwindSafe for Value

## Blanket Implementations§

Source§

### impl<T> Any for T
where T: 'static + ?Sized,

Source§

#### fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`. Read more
Source§

### impl<T> Borrow<T> for T
where T: ?Sized,

Source§

#### fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

### impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

#### fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

### impl<T> CloneToUninit for T
where T: Clone,

Source§

#### unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (`clone_to_uninit`)
Performs copy-assignment from `self` to `dest`. Read more
Source§

### impl<T> DynClone for T
where T: Clone,

Source§

#### fn __clone_box(&self, _: Private) -> *mut ()

Source§

### impl<T> From<T> for T

Source§

#### fn from(t: T) -> T

Returns the argument unchanged.

§

### impl<T> Instrument for T

§

#### fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided [`Span`], returning an `Instrumented` wrapper. Read more
§

#### fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current `Span`, returning an `Instrumented` wrapper. Read more
Source§

### impl<T, U> Into<U> for T
where U: From<T>,

Source§

#### fn into(self) -> U

Calls `U::from(self)`.

That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

§

### impl<T> PolicyExt for T
where T: ?Sized,

§

#### fn and<P, B, E>(self, other: P) -> And<T, P>
where T: Policy<B, E>, P: Policy<B, E>,

Create a new `Policy` that returns [`Action::Follow`] only if `self` and `other` return `Action::Follow`. Read more
§

#### fn or<P, B, E>(self, other: P) -> Or<T, P>
where T: Policy<B, E>, P: Policy<B, E>,

Create a new `Policy` that returns [`Action::Follow`] if either `self` or `other` returns `Action::Follow`. Read more
Source§

### impl<T> ToOwned for T
where T: Clone,

Source§

#### type Owned = T

The resulting type after obtaining ownership.
Source§

#### fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
Source§

#### fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
Source§

### impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

#### type Error = Infallible

The type returned in the event of a conversion error.
Source§

#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

### impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

#### type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

### impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

#### fn vzip(self) -> V

§

### impl<T> WithSubscriber for T

§

#### fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided `Subscriber` to this type, returning a [`WithDispatch`] wrapper. Read more
§

#### fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default `Subscriber` to this type, returning a [`WithDispatch`] wrapper. Read more
§

### impl<T> ErasedDestructor for T
where T: 'static,

§

### impl<T> MaybeSendSync for T