From 4bd0d22a2d549bfe8ee803a316aab3189d92f26c Mon Sep 17 00:00:00 2001
From: Evgeny Safronov <division494@gmail.com>
Date: Sat, 2 Apr 2016 11:53:43 +0300
Subject: [PATCH] feat(value): implement From trait

---
 rmp/src/value.rs   | 80 ++++++++++++++++++++++++++++++++++++++++++++++
 rmp/tests/value.rs | 66 ++++++++++++++++++++++++++++++++++++++
 2 files changed, 146 insertions(+)

diff --git a/rmp/src/value.rs b/rmp/src/value.rs
index e490989f..e1f418b4 100644
--- a/rmp/src/value.rs
+++ b/rmp/src/value.rs
@@ -1,5 +1,7 @@
 //! Contains Value and ValueRef structs and its conversion traits.
 
+use std::convert::From;
+
 #[derive(Copy, Clone, Debug, PartialEq)]
 pub enum Integer {
     /// Every non-negative integer is treated as u64, even if it fits in i64.
@@ -37,6 +39,84 @@ pub enum Value {
     Ext(i8, Vec<u8>),
 }
 
+impl From<bool> for Value {
+    fn from(v: bool) -> Value {
+        Value::Boolean(v)
+    }
+}
+
+impl From<u8> for Value {
+    fn from(v: u8) -> Value {
+        Value::Integer(Integer::U64(From::from(v)))
+    }
+}
+
+impl From<u16> for Value {
+    fn from(v: u16) -> Value {
+        Value::Integer(Integer::U64(From::from(v)))
+    }
+}
+
+impl From<u32> for Value {
+    fn from(v: u32) -> Value {
+        Value::Integer(Integer::U64(From::from(v)))
+    }
+}
+
+impl From<u64> for Value {
+    fn from(v: u64) -> Value {
+        Value::Integer(Integer::U64(From::from(v)))
+    }
+}
+
+impl From<usize> for Value {
+    fn from(v: usize) -> Value {
+        Value::Integer(Integer::U64(v as u64))
+    }
+}
+
+impl From<i8> for Value {
+    fn from(v: i8) -> Value {
+        Value::Integer(Integer::I64(From::from(v)))
+    }
+}
+
+impl From<i16> for Value {
+    fn from(v: i16) -> Value {
+        Value::Integer(Integer::I64(From::from(v)))
+    }
+}
+
+impl From<i32> for Value {
+    fn from(v: i32) -> Value {
+        Value::Integer(Integer::I64(From::from(v)))
+    }
+}
+
+impl From<i64> for Value {
+    fn from(v: i64) -> Value {
+        Value::Integer(Integer::I64(From::from(v)))
+    }
+}
+
+impl From<isize> for Value {
+    fn from(v: isize) -> Value {
+        Value::Integer(Integer::I64(v as i64))
+    }
+}
+
+impl From<f32> for Value {
+    fn from(v: f32) -> Value {
+        Value::Float(Float::F32(v))
+    }
+}
+
+impl From<f64> for Value {
+    fn from(v: f64) -> Value {
+        Value::Float(Float::F64(v))
+    }
+}
+
 /// Implements human-readable value formatting.
 impl ::std::fmt::Display for Value {
     fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
diff --git a/rmp/tests/value.rs b/rmp/tests/value.rs
index c5de96c2..2d0d159b 100644
--- a/rmp/tests/value.rs
+++ b/rmp/tests/value.rs
@@ -58,3 +58,69 @@ fn display_ext() {
     assert_eq!("[1, [100]]", format!("{}", Value::Ext(1, vec![100])));
     assert_eq!("[1, [100, 42]]", format!("{}", Value::Ext(1, vec![100, 42])));
 }
+
+#[test]
+fn from_bool() {
+    assert_eq!(Value::Boolean(true), Value::from(true));
+    assert_eq!(Value::Boolean(false), Value::from(false));
+}
+
+#[test]
+fn from_u8() {
+    assert_eq!(Value::Integer(Integer::U64(42)), Value::from(42u8));
+}
+
+#[test]
+fn from_u16() {
+    assert_eq!(Value::Integer(Integer::U64(42)), Value::from(42u16));
+}
+
+#[test]
+fn from_u32() {
+    assert_eq!(Value::Integer(Integer::U64(42)), Value::from(42u32));
+}
+
+#[test]
+fn from_u64() {
+    assert_eq!(Value::Integer(Integer::U64(42)), Value::from(42u64));
+}
+
+#[test]
+fn from_usize() {
+    assert_eq!(Value::Integer(Integer::U64(42)), Value::from(42usize));
+}
+
+#[test]
+fn from_i8() {
+    assert_eq!(Value::Integer(Integer::I64(-42)), Value::from(-42i8));
+}
+
+#[test]
+fn from_i16() {
+    assert_eq!(Value::Integer(Integer::I64(-42)), Value::from(-42i16));
+}
+
+#[test]
+fn from_i32() {
+    assert_eq!(Value::Integer(Integer::I64(-42)), Value::from(-42i32));
+}
+
+#[test]
+fn from_i64() {
+    assert_eq!(Value::Integer(Integer::I64(-42)), Value::from(-42i64));
+}
+
+#[test]
+fn from_isize() {
+    assert_eq!(Value::Integer(Integer::I64(-42)), Value::from(-42isize));
+}
+
+#[test]
+fn from_f32() {
+    assert_eq!(Value::Float(Float::F32(3.1415)), Value::from(3.1415f32));
+}
+
+#[test]
+fn from_f64() {
+    assert_eq!(Value::Float(Float::F64(3.1415)), Value::from(3.1415f64));
+}