From b568936c5e3eeb8c25087db22faeb1beac2c80db Mon Sep 17 00:00:00 2001
From: Daniel Larimer <dlarimer@gmail.com>
Date: Fri, 26 Oct 2012 01:00:06 -0400
Subject: [PATCH] adding tuple support to value

---
 include/fc/value.hpp      |  4 +++
 include/fc/value_cast.hpp |  1 +
 include/fc/value_io.hpp   | 66 ++++++++++++++++++++++++++++++++-------
 3 files changed, 59 insertions(+), 12 deletions(-)

diff --git a/include/fc/value.hpp b/include/fc/value.hpp
index 68f0ecc..a3c647e 100644
--- a/include/fc/value.hpp
+++ b/include/fc/value.hpp
@@ -5,6 +5,9 @@
 #include <fc/aligned.hpp>
 
 namespace fc {
+    template<typename A, typename B, typename C, typename D>
+    struct tuple;
+
     /**
      *  @brief a dynamic container that can hold
      *  integers, reals, strings, booleans, arrays, and
@@ -27,6 +30,7 @@ namespace fc {
           fc::vector<key_val>  fields;
         };
         struct array {
+          array( size_t s = 0 ):fields(s){}
           //fc::string           type;
           fc::vector<value>    fields;
         };
diff --git a/include/fc/value_cast.hpp b/include/fc/value_cast.hpp
index 8065310..9c3ec0f 100644
--- a/include/fc/value_cast.hpp
+++ b/include/fc/value_cast.hpp
@@ -193,4 +193,5 @@ namespace fc {
       new (holder) detail::value_holder(); 
       fc::pack( *this, std::forward<T>(v) );
     }
+
 }
diff --git a/include/fc/value_io.hpp b/include/fc/value_io.hpp
index e1db815..58b9b84 100644
--- a/include/fc/value_io.hpp
+++ b/include/fc/value_io.hpp
@@ -4,6 +4,7 @@
 #include <fc/optional.hpp>
 #include <fc/value.hpp>
 #include <fc/value_cast.hpp>
+#include <fc/tuple.hpp>
 
 namespace fc {
   struct void_t{};
@@ -14,12 +15,18 @@ namespace fc {
   template<typename T> 
   void unpack( const fc::value& jsv, T& v ); 
 
+  template<typename A, typename B, typename C, typename D>
+  void pack( fc::value& v, const tuple<A,B,C,D>& t );
+  template<typename A, typename B, typename C, typename D>
+  void unpack( const fc::value& val, tuple<A,B,C,D>& t ); 
+
   template<typename T> 
   void pack( fc::value& jsv, const fc::optional<T>& v );
 
   template<typename T> 
   void unpack( const fc::value& jsv, fc::optional<T>& v );
 
+  inline void pack( fc::value& jsv, const char& v )         { jsv = fc::string(&v,1); }
   inline void pack( fc::value& jsv, const fc::value& v )    { jsv = v; }
   inline void pack( fc::value& jsv, fc::value& v )          { jsv = v; }
   inline void pack( fc::value& jsv, fc::value&& v )         { jsv = fc::move(v); }
@@ -189,18 +196,22 @@ namespace fc {
 
   } // namesapce detail
 
-  inline void unpack( const fc::value& jsv, bool& v )         { v = value_cast<bool>(jsv);       }
-  inline void unpack( const fc::value& jsv, float& v )        { v = value_cast<float>(jsv);      }
-  inline void unpack( const fc::value& jsv, double& v )       { v = value_cast<double>(jsv);     }
-  inline void unpack( const fc::value& jsv, uint8_t& v )      { v = value_cast<uint8_t>(jsv);    }
-  inline void unpack( const fc::value& jsv, uint16_t& v )     { v = value_cast<uint16_t>(jsv);   }
-  inline void unpack( const fc::value& jsv, uint32_t& v )     { v = value_cast<uint32_t>(jsv);   }
-  inline void unpack( const fc::value& jsv, uint64_t& v )     { v = value_cast<uint64_t>(jsv);   }
-  inline void unpack( const fc::value& jsv, int8_t& v )       { v = value_cast<int8_t>(jsv);     }
-  inline void unpack( const fc::value& jsv, int16_t& v )      { v = value_cast<int16_t>(jsv);    }
-  inline void unpack( const fc::value& jsv, int32_t& v )      { v = value_cast<int32_t>(jsv);    }
-  inline void unpack( const fc::value& jsv, int64_t& v )      { v = value_cast<int64_t>(jsv);    }
-  inline void unpack( const fc::value& jsv, fc::string& v )   { v = value_cast<fc::string>(jsv); }
+  inline void unpack( const fc::value& jsv, char& v )         { 
+    auto s = value_cast<fc::string>(jsv); 
+    if( s.size() ) v = s[0];
+  }
+  inline void unpack( const fc::value& jsv, bool& v )         { v = value_cast<bool>(jsv);          }
+  inline void unpack( const fc::value& jsv, float& v )        { v = value_cast<float>(jsv);         }
+  inline void unpack( const fc::value& jsv, double& v )       { v = value_cast<double>(jsv);        }
+  inline void unpack( const fc::value& jsv, uint8_t& v )      { v = value_cast<uint8_t>(jsv);       }
+  inline void unpack( const fc::value& jsv, uint16_t& v )     { v = value_cast<uint16_t>(jsv);      }
+  inline void unpack( const fc::value& jsv, uint32_t& v )     { v = value_cast<uint32_t>(jsv);      }
+  inline void unpack( const fc::value& jsv, uint64_t& v )     { v = value_cast<uint64_t>(jsv);      }
+  inline void unpack( const fc::value& jsv, int8_t& v )       { v = value_cast<int8_t>(jsv);        }
+  inline void unpack( const fc::value& jsv, int16_t& v )      { v = value_cast<int16_t>(jsv);       }
+  inline void unpack( const fc::value& jsv, int32_t& v )      { v = value_cast<int32_t>(jsv);       }
+  inline void unpack( const fc::value& jsv, int64_t& v )      { v = value_cast<int64_t>(jsv);       }
+  inline void unpack( const fc::value& jsv, fc::string& v )   { v = value_cast<fc::string>(jsv);    }
 
   template<typename T> 
   void pack( fc::value& jsv, const fc::optional<T>& v ) {
@@ -230,6 +241,37 @@ namespace fc {
           ++i;
       }
   }
+  struct tuple_to_value_visitor {
+    tuple_to_value_visitor( value& v ):_val(v),_count(0) { }
+    template<typename T>
+    void operator()( T&& t ) {
+      _val[_count] = value(fc::forward<T>(t) );
+      ++_count;
+    }
+    value& _val;
+    int    _count;
+  };
+  struct tuple_from_value_visitor {
+    tuple_from_value_visitor( const value& v ):_val(v),_count(0) { }
+    template<typename T>
+    void operator()( T&& t ) {
+      if( _count < _val.size() ) unpack( _val[_count], t );
+      ++_count;
+    }
+    const value& _val;
+    int    _count;
+  };
+
+  template<typename A, typename B, typename C, typename D>
+  inline void pack( fc::value& val, const tuple<A,B,C,D>& t ) {
+    val = fc::value::array( tuple<A,B,C,D>::size );
+    t.visit( tuple_to_value_visitor(val) );
+  }
+  template<typename A, typename B, typename C, typename D>
+  inline void unpack( const fc::value& val, tuple<A,B,C,D>& t ) {
+    val = fc::value::array( tuple<A,B,C,D>::size );
+    t.visit( tuple_from_value_visitor(val) );
+  }
 
   template<typename T>
   inline void unpack( const fc::value& jsv, fc::vector<T>& val ) {