use std::collections::{BTreeMap, BTreeSet};
use std::collections::{HashMap, HashSet};
use std::convert::From;
use std::default::Default;
use std::error;
use std::fmt;
use std::hash::{BuildHasher, Hash};
use std::io;
use std::str::{from_utf8, Utf8Error};
use futures::Future;
#[derive(PartialEq, Eq, Clone, Debug, Copy)]
pub enum NumericBehavior {
NonNumeric,
NumberIsInteger,
NumberIsFloat,
}
#[derive(PartialEq, Eq, Copy, Clone, Debug)]
pub enum ErrorKind {
ResponseError,
AuthenticationFailed,
TypeError,
ExecAbortError,
BusyLoadingError,
NoScriptError,
InvalidClientConfig,
IoError,
ExtensionError,
}
#[derive(PartialEq, Eq, Clone)]
pub enum Value {
Nil,
Int(i64),
Data(Vec<u8>),
Bulk(Vec<Value>),
Status(String),
Okay,
}
impl Value {
pub fn looks_like_cursor(&self) -> bool {
match *self {
Value::Bulk(ref items) => {
if items.len() != 2 {
return false;
}
match items[0] {
Value::Data(_) => {}
_ => {
return false;
}
};
match items[1] {
Value::Bulk(_) => {}
_ => {
return false;
}
}
return true;
}
_ => {
return false;
}
}
}
}
impl fmt::Debug for Value {
fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
match *self {
Value::Nil => write!(fmt, "nil"),
Value::Int(val) => write!(fmt, "int({:?})", val),
Value::Data(ref val) => match from_utf8(val) {
Ok(x) => write!(fmt, "string-data('{:?}')", x),
Err(_) => write!(fmt, "binary-data({:?})", val),
},
Value::Bulk(ref values) => {
write!(fmt, "bulk(")?;
let mut is_first = true;
for val in values.iter() {
if !is_first {
write!(fmt, ", ")?;
}
write!(fmt, "{:?}", val)?;
is_first = false;
}
write!(fmt, ")")
}
Value::Okay => write!(fmt, "ok"),
Value::Status(ref s) => write!(fmt, "status({:?})", s),
}
}
}
pub struct RedisError {
repr: ErrorRepr,
}
#[derive(Debug)]
enum ErrorRepr {
WithDescription(ErrorKind, &'static str),
WithDescriptionAndDetail(ErrorKind, &'static str, String),
ExtensionError(String, String),
IoError(io::Error),
}
impl PartialEq for RedisError {
fn eq(&self, other: &RedisError) -> bool {
match (&self.repr, &other.repr) {
(&ErrorRepr::WithDescription(kind_a, _), &ErrorRepr::WithDescription(kind_b, _)) => {
kind_a == kind_b
}
(
&ErrorRepr::WithDescriptionAndDetail(kind_a, _, _),
&ErrorRepr::WithDescriptionAndDetail(kind_b, _, _),
) => kind_a == kind_b,
(&ErrorRepr::ExtensionError(ref a, _), &ErrorRepr::ExtensionError(ref b, _)) => {
*a == *b
}
_ => false,
}
}
}
impl From<io::Error> for RedisError {
fn from(err: io::Error) -> RedisError {
RedisError {
repr: ErrorRepr::IoError(err),
}
}
}
impl From<Utf8Error> for RedisError {
fn from(_: Utf8Error) -> RedisError {
RedisError {
repr: ErrorRepr::WithDescription(ErrorKind::TypeError, "Invalid UTF-8"),
}
}
}
impl From<(ErrorKind, &'static str)> for RedisError {
fn from((kind, desc): (ErrorKind, &'static str)) -> RedisError {
RedisError {
repr: ErrorRepr::WithDescription(kind, desc),
}
}
}
impl From<(ErrorKind, &'static str, String)> for RedisError {
fn from((kind, desc, detail): (ErrorKind, &'static str, String)) -> RedisError {
RedisError {
repr: ErrorRepr::WithDescriptionAndDetail(kind, desc, detail),
}
}
}
impl error::Error for RedisError {
fn description(&self) -> &str {
match self.repr {
ErrorRepr::WithDescription(_, desc) => desc,
ErrorRepr::WithDescriptionAndDetail(_, desc, _) => desc,
ErrorRepr::ExtensionError(_, _) => "extension error",
ErrorRepr::IoError(ref err) => err.description(),
}
}
fn cause(&self) -> Option<&dyn error::Error> {
match self.repr {
ErrorRepr::IoError(ref err) => Some(err as &dyn error::Error),
_ => None,
}
}
}
impl fmt::Display for RedisError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
match self.repr {
ErrorRepr::WithDescription(_, desc) => desc.fmt(f),
ErrorRepr::WithDescriptionAndDetail(_, desc, ref detail) => {
desc.fmt(f)?;
f.write_str(": ")?;
detail.fmt(f)
}
ErrorRepr::ExtensionError(ref code, ref detail) => {
code.fmt(f)?;
f.write_str(": ")?;
detail.fmt(f)
}
ErrorRepr::IoError(ref err) => err.fmt(f),
}
}
}
impl fmt::Debug for RedisError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
fmt::Display::fmt(self, f)
}
}
impl RedisError {
pub fn kind(&self) -> ErrorKind {
match self.repr {
ErrorRepr::WithDescription(kind, _) => kind,
ErrorRepr::WithDescriptionAndDetail(kind, _, _) => kind,
ErrorRepr::ExtensionError(_, _) => ErrorKind::ExtensionError,
ErrorRepr::IoError(_) => ErrorKind::IoError,
}
}
pub fn category(&self) -> &str {
match self.kind() {
ErrorKind::ResponseError => "response error",
ErrorKind::AuthenticationFailed => "authentication failed",
ErrorKind::TypeError => "type error",
ErrorKind::ExecAbortError => "script execution aborted",
ErrorKind::BusyLoadingError => "busy loading",
ErrorKind::NoScriptError => "no script",
ErrorKind::InvalidClientConfig => "invalid client config",
ErrorKind::IoError => "I/O error",
ErrorKind::ExtensionError => "extension error",
}
}
pub fn is_io_error(&self) -> bool {
match self.kind() {
ErrorKind::IoError => true,
_ => false,
}
}
pub fn is_connection_refusal(&self) -> bool {
match self.repr {
ErrorRepr::IoError(ref err) => {
match err.kind() {
io::ErrorKind::ConnectionRefused => true,
io::ErrorKind::NotFound => cfg!(unix),
_ => false,
}
}
_ => false,
}
}
pub fn is_timeout(&self) -> bool {
match self.repr {
ErrorRepr::IoError(ref err) => match err.kind() {
io::ErrorKind::TimedOut => true,
io::ErrorKind::WouldBlock => true,
_ => false,
},
_ => false,
}
}
pub fn is_connection_dropped(&self) -> bool {
match self.repr {
ErrorRepr::IoError(ref err) => match err.kind() {
io::ErrorKind::BrokenPipe | io::ErrorKind::ConnectionReset => true,
_ => false,
},
_ => false,
}
}
pub fn extension_error_code(&self) -> Option<&str> {
match self.repr {
ErrorRepr::ExtensionError(ref code, _) => Some(&code),
_ => None,
}
}
}
pub fn make_extension_error(code: &str, detail: Option<&str>) -> RedisError {
RedisError {
repr: ErrorRepr::ExtensionError(
code.to_string(),
match detail {
Some(x) => x.to_string(),
None => "Unknown extension error encountered".to_string(),
},
),
}
}
pub type RedisResult<T> = Result<T, RedisError>;
pub type RedisFuture<T> = Box<dyn Future<Item = T, Error = RedisError> + Send>;
#[derive(Debug)]
pub struct InfoDict {
map: HashMap<String, Value>,
}
impl InfoDict {
pub fn new(kvpairs: &str) -> InfoDict {
let mut map = HashMap::new();
for line in kvpairs.lines() {
if line.len() == 0 || line.starts_with("#") {
continue;
}
let mut p = line.splitn(2, ':');
let k = unwrap_or!(p.next(), continue).to_string();
let v = unwrap_or!(p.next(), continue).to_string();
map.insert(k, Value::Status(v));
}
InfoDict { map: map }
}
pub fn get<T: FromRedisValue>(&self, key: &str) -> Option<T> {
match self.find(&key) {
Some(ref x) => from_redis_value(*x).ok(),
None => None,
}
}
pub fn find(&self, key: &&str) -> Option<&Value> {
self.map.get(*key)
}
pub fn contains_key(&self, key: &&str) -> bool {
self.find(key).is_some()
}
pub fn len(&self) -> usize {
self.map.len()
}
}
pub trait RedisWrite {
fn write_arg(&mut self, arg: &[u8]);
}
impl RedisWrite for Vec<Vec<u8>> {
fn write_arg(&mut self, arg: &[u8]) {
self.push(arg.to_owned());
}
}
pub trait ToRedisArgs: Sized {
fn to_redis_args(&self) -> Vec<Vec<u8>> {
let mut out = Vec::new();
self.write_redis_args(&mut out);
out
}
fn write_redis_args<W>(&self, out: &mut W)
where
W: ?Sized + RedisWrite;
fn describe_numeric_behavior(&self) -> NumericBehavior {
NumericBehavior::NonNumeric
}
fn is_single_arg(&self) -> bool {
true
}
#[doc(hidden)]
fn make_arg_vec<W>(items: &[Self], out: &mut W)
where
W: ?Sized + RedisWrite,
{
for item in items.iter() {
item.write_redis_args(out);
}
}
#[doc(hidden)]
fn make_arg_iter_ref<'a, I, W>(items: I, out: &mut W)
where
W: ?Sized + RedisWrite,
I: Iterator<Item = &'a Self>,
Self: 'a,
{
for item in items {
item.write_redis_args(out);
}
}
#[doc(hidden)]
fn is_single_vec_arg(items: &[Self]) -> bool {
items.len() == 1 && items[0].is_single_arg()
}
}
macro_rules! invalid_type_error {
($v:expr, $det:expr) => {{
fail!((
ErrorKind::TypeError,
"Response was of incompatible type",
format!("{:?} (response was {:?})", $det, $v)
));
}};
}
macro_rules! itoa_based_to_redis_impl {
($t:ty, $numeric:expr) => {
impl ToRedisArgs for $t {
fn write_redis_args<W>(&self, out: &mut W)
where
W: ?Sized + RedisWrite,
{
let mut buf = ::itoa::Buffer::new();
let s = buf.format(*self);
out.write_arg(s.as_bytes())
}
fn describe_numeric_behavior(&self) -> NumericBehavior {
$numeric
}
}
};
}
macro_rules! dtoa_based_to_redis_impl {
($t:ty, $numeric:expr) => {
impl ToRedisArgs for $t {
fn write_redis_args<W>(&self, out: &mut W)
where
W: ?Sized + RedisWrite,
{
let mut buf = Vec::new();
::dtoa::write(&mut buf, *self).unwrap();
out.write_arg(&buf)
}
fn describe_numeric_behavior(&self) -> NumericBehavior {
$numeric
}
}
};
}
impl ToRedisArgs for u8 {
fn write_redis_args<W>(&self, out: &mut W)
where
W: ?Sized + RedisWrite,
{
let mut buf = [0u8; 3];
let n = ::itoa::write(&mut buf[..], *self).unwrap();
out.write_arg(&buf[..n])
}
fn make_arg_vec<W>(items: &[u8], out: &mut W)
where
W: ?Sized + RedisWrite,
{
out.write_arg(items);
}
fn is_single_vec_arg(_items: &[u8]) -> bool {
true
}
}
itoa_based_to_redis_impl!(i8, NumericBehavior::NumberIsInteger);
itoa_based_to_redis_impl!(i16, NumericBehavior::NumberIsInteger);
itoa_based_to_redis_impl!(u16, NumericBehavior::NumberIsInteger);
itoa_based_to_redis_impl!(i32, NumericBehavior::NumberIsInteger);
itoa_based_to_redis_impl!(u32, NumericBehavior::NumberIsInteger);
itoa_based_to_redis_impl!(i64, NumericBehavior::NumberIsInteger);
itoa_based_to_redis_impl!(u64, NumericBehavior::NumberIsInteger);
itoa_based_to_redis_impl!(isize, NumericBehavior::NumberIsInteger);
itoa_based_to_redis_impl!(usize, NumericBehavior::NumberIsInteger);
dtoa_based_to_redis_impl!(f32, NumericBehavior::NumberIsFloat);
dtoa_based_to_redis_impl!(f64, NumericBehavior::NumberIsFloat);
impl ToRedisArgs for bool {
fn write_redis_args<W>(&self, out: &mut W)
where
W: ?Sized + RedisWrite,
{
out.write_arg(if *self { b"true" } else { b"false" })
}
}
impl ToRedisArgs for String {
fn write_redis_args<W>(&self, out: &mut W)
where
W: ?Sized + RedisWrite,
{
out.write_arg(self.as_bytes())
}
}
impl<'a> ToRedisArgs for &'a String {
fn write_redis_args<W>(&self, out: &mut W)
where
W: ?Sized + RedisWrite,
{
out.write_arg(self.as_bytes())
}
}
impl<'a> ToRedisArgs for &'a str {
fn write_redis_args<W>(&self, out: &mut W)
where
W: ?Sized + RedisWrite,
{
out.write_arg(self.as_bytes())
}
}
impl<T: ToRedisArgs> ToRedisArgs for Vec<T> {
fn write_redis_args<W>(&self, out: &mut W)
where
W: ?Sized + RedisWrite,
{
ToRedisArgs::make_arg_vec(self, out)
}
fn is_single_arg(&self) -> bool {
ToRedisArgs::is_single_vec_arg(&self[..])
}
}
impl<'a, T: ToRedisArgs> ToRedisArgs for &'a [T] {
fn write_redis_args<W>(&self, out: &mut W)
where
W: ?Sized + RedisWrite,
{
ToRedisArgs::make_arg_vec(*self, out)
}
fn is_single_arg(&self) -> bool {
ToRedisArgs::is_single_vec_arg(*self)
}
}
impl<T: ToRedisArgs> ToRedisArgs for Option<T> {
fn write_redis_args<W>(&self, out: &mut W)
where
W: ?Sized + RedisWrite,
{
match *self {
Some(ref x) => x.write_redis_args(out),
None => (),
}
}
fn describe_numeric_behavior(&self) -> NumericBehavior {
match *self {
Some(ref x) => x.describe_numeric_behavior(),
None => NumericBehavior::NonNumeric,
}
}
fn is_single_arg(&self) -> bool {
match *self {
Some(ref x) => x.is_single_arg(),
None => false,
}
}
}
impl<T: ToRedisArgs + Hash + Eq, S: BuildHasher + Default> ToRedisArgs for HashSet<T, S> {
fn write_redis_args<W>(&self, out: &mut W)
where
W: ?Sized + RedisWrite,
{
ToRedisArgs::make_arg_iter_ref(self.iter(), out)
}
fn is_single_arg(&self) -> bool {
self.len() <= 1
}
}
impl<T: ToRedisArgs + Hash + Eq + Ord> ToRedisArgs for BTreeSet<T> {
fn write_redis_args<W>(&self, out: &mut W)
where
W: ?Sized + RedisWrite,
{
ToRedisArgs::make_arg_iter_ref(self.iter(), out)
}
fn is_single_arg(&self) -> bool {
self.len() <= 1
}
}
impl<T: ToRedisArgs + Hash + Eq + Ord, V: ToRedisArgs> ToRedisArgs for BTreeMap<T, V> {
fn write_redis_args<W>(&self, out: &mut W)
where
W: ?Sized + RedisWrite,
{
for (key, value) in self {
assert!(key.is_single_arg() && value.is_single_arg());
key.write_redis_args(out);
value.write_redis_args(out);
}
}
fn is_single_arg(&self) -> bool {
self.len() <= 1
}
}
macro_rules! to_redis_args_for_tuple {
() => ();
($($name:ident,)+) => (
#[doc(hidden)]
impl<$($name: ToRedisArgs),*> ToRedisArgs for ($($name,)*) {
#[allow(non_snake_case, unused_variables)]
fn write_redis_args<W>(&self, out: &mut W) where W: ?Sized + RedisWrite {
let ($(ref $name,)*) = *self;
$($name.write_redis_args(out);)*
}
#[allow(non_snake_case, unused_variables)]
fn is_single_arg(&self) -> bool {
let mut n = 0u32;
$(let $name = (); n += 1;)*
n == 1
}
}
to_redis_args_for_tuple_peel!($($name,)*);
)
}
macro_rules! to_redis_args_for_tuple_peel {
($name:ident, $($other:ident,)*) => (to_redis_args_for_tuple!($($other,)*);)
}
to_redis_args_for_tuple! { T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, }
macro_rules! to_redis_args_for_array {
($($N:expr)+) => {
$(
impl<'a, T: ToRedisArgs> ToRedisArgs for &'a [T; $N] {
fn write_redis_args<W>(&self, out: &mut W) where W: ?Sized + RedisWrite {
ToRedisArgs::make_arg_vec(*self, out)
}
fn is_single_arg(&self) -> bool {
ToRedisArgs::is_single_vec_arg(*self)
}
}
)+
}
}
to_redis_args_for_array! {
0 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
}
pub trait FromRedisValue: Sized {
fn from_redis_value(v: &Value) -> RedisResult<Self>;
fn from_redis_values(items: &[Value]) -> RedisResult<Vec<Self>> {
let mut rv = vec![];
for item in items.iter() {
match FromRedisValue::from_redis_value(item) {
Ok(val) => rv.push(val),
Err(_) => {}
}
}
Ok(rv)
}
#[doc(hidden)]
fn from_byte_vec(_vec: &[u8]) -> Option<Vec<Self>> {
None
}
}
macro_rules! from_redis_value_for_num_internal {
($t:ty, $v:expr) => {{
let v = $v;
match *v {
Value::Int(val) => Ok(val as $t),
Value::Status(ref s) => match s.parse::<$t>() {
Ok(rv) => Ok(rv),
Err(_) => invalid_type_error!(v, "Could not convert from string."),
},
Value::Data(ref bytes) => match from_utf8(bytes)?.parse::<$t>() {
Ok(rv) => Ok(rv),
Err(_) => invalid_type_error!(v, "Could not convert from string."),
},
_ => invalid_type_error!(v, "Response type not convertible to numeric."),
}
}};
}
macro_rules! from_redis_value_for_num {
($t:ty) => {
impl FromRedisValue for $t {
fn from_redis_value(v: &Value) -> RedisResult<$t> {
from_redis_value_for_num_internal!($t, v)
}
}
};
}
impl FromRedisValue for u8 {
fn from_redis_value(v: &Value) -> RedisResult<u8> {
from_redis_value_for_num_internal!(u8, v)
}
fn from_byte_vec(vec: &[u8]) -> Option<Vec<u8>> {
Some(vec.to_vec())
}
}
from_redis_value_for_num!(i8);
from_redis_value_for_num!(i16);
from_redis_value_for_num!(u16);
from_redis_value_for_num!(i32);
from_redis_value_for_num!(u32);
from_redis_value_for_num!(i64);
from_redis_value_for_num!(u64);
from_redis_value_for_num!(f32);
from_redis_value_for_num!(f64);
from_redis_value_for_num!(isize);
from_redis_value_for_num!(usize);
impl FromRedisValue for bool {
fn from_redis_value(v: &Value) -> RedisResult<bool> {
match *v {
Value::Nil => Ok(false),
Value::Int(val) => Ok(val != 0),
Value::Status(ref s) => {
if &s[..] == "1" {
Ok(true)
} else if &s[..] == "0" {
Ok(false)
} else {
invalid_type_error!(v, "Response status not valid boolean");
}
}
Value::Okay => Ok(true),
_ => invalid_type_error!(v, "Response type not bool compatible."),
}
}
}
impl FromRedisValue for String {
fn from_redis_value(v: &Value) -> RedisResult<String> {
match *v {
Value::Data(ref bytes) => Ok(from_utf8(bytes)?.to_string()),
Value::Okay => Ok("OK".to_string()),
Value::Status(ref val) => Ok(val.to_string()),
_ => invalid_type_error!(v, "Response type not string compatible."),
}
}
}
impl<T: FromRedisValue> FromRedisValue for Vec<T> {
fn from_redis_value(v: &Value) -> RedisResult<Vec<T>> {
match *v {
Value::Data(ref bytes) => match FromRedisValue::from_byte_vec(bytes) {
Some(x) => Ok(x),
None => invalid_type_error!(v, "Response type not vector compatible."),
},
Value::Bulk(ref items) => FromRedisValue::from_redis_values(items),
Value::Nil => Ok(vec![]),
_ => invalid_type_error!(v, "Response type not vector compatible."),
}
}
}
impl<K: FromRedisValue + Eq + Hash, V: FromRedisValue, S: BuildHasher + Default> FromRedisValue
for HashMap<K, V, S>
{
fn from_redis_value(v: &Value) -> RedisResult<HashMap<K, V, S>> {
match *v {
Value::Bulk(ref items) => {
let mut rv = HashMap::default();
let mut iter = items.iter();
loop {
let k = unwrap_or!(iter.next(), break);
let v = unwrap_or!(iter.next(), break);
rv.insert(from_redis_value(k)?, from_redis_value(v)?);
}
Ok(rv)
}
_ => invalid_type_error!(v, "Response type not hashmap compatible"),
}
}
}
impl<K: FromRedisValue + Eq + Hash, V: FromRedisValue> FromRedisValue for BTreeMap<K, V>
where
K: Ord,
{
fn from_redis_value(v: &Value) -> RedisResult<BTreeMap<K, V>> {
match *v {
Value::Bulk(ref items) => {
let mut rv = BTreeMap::new();
let mut iter = items.iter();
loop {
let k = unwrap_or!(iter.next(), break);
let v = unwrap_or!(iter.next(), break);
rv.insert(from_redis_value(k)?, from_redis_value(v)?);
}
Ok(rv)
}
_ => invalid_type_error!(v, "Response type not btreemap compatible"),
}
}
}
impl<T: FromRedisValue + Eq + Hash, S: BuildHasher + Default> FromRedisValue for HashSet<T, S> {
fn from_redis_value(v: &Value) -> RedisResult<HashSet<T, S>> {
match *v {
Value::Bulk(ref items) => {
let mut rv = HashSet::default();
for item in items.iter() {
rv.insert(from_redis_value(item)?);
}
Ok(rv)
}
_ => invalid_type_error!(v, "Response type not hashset compatible"),
}
}
}
impl<T: FromRedisValue + Eq + Hash> FromRedisValue for BTreeSet<T>
where
T: Ord,
{
fn from_redis_value(v: &Value) -> RedisResult<BTreeSet<T>> {
match *v {
Value::Bulk(ref items) => {
let mut rv = BTreeSet::new();
for item in items.iter() {
rv.insert(from_redis_value(item)?);
}
Ok(rv)
}
_ => invalid_type_error!(v, "Response type not btreeset compatible"),
}
}
}
impl FromRedisValue for Value {
fn from_redis_value(v: &Value) -> RedisResult<Value> {
Ok(v.clone())
}
}
impl FromRedisValue for () {
fn from_redis_value(_v: &Value) -> RedisResult<()> {
Ok(())
}
}
macro_rules! from_redis_value_for_tuple {
() => ();
($($name:ident,)+) => (
#[doc(hidden)]
impl<$($name: FromRedisValue),*> FromRedisValue for ($($name,)*) {
#[allow(non_snake_case, unused_variables)]
fn from_redis_value(v: &Value) -> RedisResult<($($name,)*)> {
match *v {
Value::Bulk(ref items) => {
let mut n = 0;
$(let $name = (); n += 1;)*
if items.len() != n {
invalid_type_error!(v, "Bulk response of wrong dimension")
}
let mut i = 0;
Ok(($({let $name = (); from_redis_value(
&items[{ i += 1; i - 1 }])?},)*))
}
_ => invalid_type_error!(v, "Not a bulk response")
}
}
#[allow(non_snake_case, unused_variables)]
fn from_redis_values(items: &[Value]) -> RedisResult<Vec<($($name,)*)>> {
let mut n = 0;
$(let $name = (); n += 1;)*
if items.len() % n != 0 {
invalid_type_error!(items, "Bulk response of wrong dimension")
}
let mut rv = vec![];
if items.len() == 0 {
return Ok(rv)
}
let mut offset = 0;
while offset < items.len() - 1 {
rv.push(($({let $name = (); from_redis_value(
&items[{ offset += 1; offset - 1 }])?},)*));
}
Ok(rv)
}
}
from_redis_value_for_tuple_peel!($($name,)*);
)
}
macro_rules! from_redis_value_for_tuple_peel {
($name:ident, $($other:ident,)*) => (from_redis_value_for_tuple!($($other,)*);)
}
from_redis_value_for_tuple! { T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, }
impl FromRedisValue for InfoDict {
fn from_redis_value(v: &Value) -> RedisResult<InfoDict> {
let s: String = from_redis_value(v)?;
Ok(InfoDict::new(&s))
}
}
impl<T: FromRedisValue> FromRedisValue for Option<T> {
fn from_redis_value(v: &Value) -> RedisResult<Option<T>> {
match *v {
Value::Nil => {
return Ok(None);
}
_ => {}
}
Ok(Some(from_redis_value(v)?))
}
}
pub fn from_redis_value<T: FromRedisValue>(v: &Value) -> RedisResult<T> {
FromRedisValue::from_redis_value(v)
}