From 4b9519d20788f9da6b82a94e036cae7c77cb4798 Mon Sep 17 00:00:00 2001
From: Ryan Leckey <leckey.ryan@gmail.com>
Date: Mon, 30 Jan 2017 14:56:49 -0800
Subject: :shirt:

---
 src/value.rs | 77 +++++++++++++++++++++++++++---------------------------------
 1 file changed, 34 insertions(+), 43 deletions(-)

(limited to 'src/value.rs')

diff --git a/src/value.rs b/src/value.rs
index 82aef4c..561394d 100644
--- a/src/value.rs
+++ b/src/value.rs
@@ -19,65 +19,56 @@ pub enum Value<'a> {
 impl<'a> Value<'a> {
     /// Gets the underlying value as a string, performing a conversion only if neccessary.
     pub fn as_str(&'a self) -> Option<Cow<'a, str>> {
-        if let Value::String(ref value) = *self {
-            Some(Cow::Borrowed(&*value))
-        } else if let Value::Integer(value) = *self {
-            Some(Cow::Owned(value.to_string()))
-        } else if let Value::Float(value) = *self {
-            Some(Cow::Owned(value.to_string()))
-        } else if let Value::Boolean(value) = *self {
-            Some(Cow::Owned(value.to_string()))
-        } else {
-            None
+        match *self {
+            Value::String(ref value) => Some(Cow::Borrowed(&*value)),
+            Value::Integer(value) => Some(value.to_string().into()),
+            Value::Float(value) => Some(value.to_string().into()),
+            Value::Boolean(value) => Some(value.to_string().into()),
+
+            _ => unimplemented!()
         }
     }
 
     /// Gets the underlying type as a boolean, performing a conversion only if neccessary.
     pub fn as_bool(&self) -> Option<bool> {
-        if let Value::Boolean(value) = *self {
-            Some(value)
-        } else if let Value::String(ref value) = *self {
-            match value.to_lowercase().as_ref() {
-                "1" | "true" | "on" | "yes" => Some(true),
-                "0" | "false" | "off" | "no" => Some(false),
-                _ => None,
+        match *self {
+            Value::Boolean(value) => Some(value),
+            Value::Integer(value) => Some(value != 0),
+            Value::Float(value) => Some(value != 0.0),
+
+            Value::String(ref value) => {
+                match value.to_lowercase().as_ref() {
+                    "1" | "true" | "on" | "yes" => Some(true),
+                    "0" | "false" | "off" | "no" => Some(false),
+                    _ => None,
+                }
             }
-        } else if let Value::Integer(value) = *self {
-            Some(value != 0)
-        } else if let Value::Float(value) = *self {
-            Some(value != 0.0)
-        } else {
-            None
+
+            _ => unimplemented!()
         }
     }
 
     /// Gets the underlying type as an integer, performing a conversion only if neccessary.
     pub fn as_int(&self) -> Option<i64> {
-        if let Value::Integer(value) = *self {
-            Some(value)
-        } else if let Value::String(ref value) = *self {
-            value.parse().ok()
-        } else if let Value::Boolean(value) = *self {
-            Some(if value { 1 } else { 0 })
-        } else if let Value::Float(value) = *self {
-            Some(value.round() as i64)
-        } else {
-            None
+        match *self {
+            Value::Integer(value) => Some(value),
+            Value::String(ref value) => value.parse().ok(),
+            Value::Boolean(value) => Some(if value { 1 } else { 0 }),
+            Value::Float(value) => Some(value.round() as i64),
+
+            _ => unimplemented!()
         }
     }
 
     /// Gets the underlying type as a floating-point, performing a conversion only if neccessary.
     pub fn as_float(&self) -> Option<f64> {
-        if let Value::Float(value) = *self {
-            Some(value)
-        } else if let Value::String(ref value) = *self {
-            value.parse().ok()
-        } else if let Value::Integer(value) = *self {
-            Some(value as f64)
-        } else if let Value::Boolean(value) = *self {
-            Some(if value { 1.0 } else { 0.0 })
-        } else {
-            None
+        match *self {
+            Value::Float(value) => Some(value),
+            Value::String(ref value) => value.parse().ok(),
+            Value::Integer(value) => Some(value as f64),
+            Value::Boolean(value) => Some(if value { 1.0 } else { 0.0 }),
+
+            _ => unimplemented!()
         }
     }
 }
-- 
cgit v1.2.3