deque: Add std::deque to serialization / reflection

include/fc/container/deque.hpp

@@ -0,0 +1,52 @@
+#pragma once
+
+#include <deque>
+
+namespace fc {
+   namespace raw {
+
+    template<typename Stream, typename T>
+    inline void pack( Stream& s, const std::deque<T>& value ) {
+      pack( s, unsigned_int((uint32_t)value.size()) );
+      auto itr = value.begin();
+      auto end = value.end();
+      while( itr != end ) {
+        fc::raw::pack( s, *itr );
+        ++itr;
+      }
+    }
+
+    template<typename Stream, typename T>
+    inline void unpack( Stream& s, std::deque<T>& value ) {
+      unsigned_int size; unpack( s, size );
+      FC_ASSERT( size.value*sizeof(T) < MAX_ARRAY_ALLOC_SIZE );
+      value.resize(size.value);
+      auto itr = value.begin();
+      auto end = value.end();
+      while( itr != end ) {
+        fc::raw::unpack( s, *itr );
+        ++itr;
+      }
+    }
+
+    } // namespace raw
+
+   template<typename T>
+   void to_variant( const std::deque<T>& var,  variant& vo )
+   {
+       std::vector<variant> vars(var.size());
+       size_t i = 0;
+       for( auto itr = var.begin(); itr != var.end(); ++itr, ++i )
+          vars[i] = variant(*itr);
+       vo = vars;
+   }
+   template<typename T>
+   void from_variant( const variant& var,  std::deque<T>& vo )
+   {
+      const variants& vars = var.get_array();
+      vo.clear();
+      vo.reserve( vars.size() );
+      for( auto itr = vars.begin(); itr != vars.end(); ++itr )
+         vo.insert( itr->as<T>() );
+   }
+} // namespace fc

include/fc/container/deque_fwd.hpp

@@ -0,0 +1,13 @@
+#pragma once
+
+#include <deque>
+
+namespace fc {
+
+   namespace raw {
+       template<typename Stream, typename T>
+       void pack( Stream& s, const std::deque<T>& value );
+       template<typename Stream, typename T>
+       void unpack( Stream& s, std::deque<T>& value );
+   }
+} // namespace fc

include/fc/io/raw_fwd.hpp

@@ -1,8 +1,10 @@
 #pragma once
 #include <fc/container/flat_fwd.hpp>
+#include <fc/container/deque_fwd.hpp>
 #include <fc/io/varint.hpp>
 #include <fc/array.hpp>
 #include <fc/safe.hpp>
+#include <deque>
 #include <vector>
 #include <string>
 #include <unordered_set>
@@ -40,6 +42,9 @@ namespace fc {
     template<typename Stream, typename T> inline void pack( Stream& s, const flat_set<T>& value );
     template<typename Stream, typename T> inline void unpack( Stream& s, flat_set<T>& value );
 
+    template<typename Stream, typename T> inline void pack( Stream& s, const std::deque<T>& value );
+    template<typename Stream, typename T> inline void unpack( Stream& s, std::deque<T>& value );
+
     template<typename Stream, typename K, typename V> inline void pack( Stream& s, const std::unordered_map<K,V>& value );
     template<typename Stream, typename K, typename V> inline void unpack( Stream& s, std::unordered_map<K,V>& value );
 

include/fc/reflect/typename.hpp

@@ -1,9 +1,14 @@
 #pragma once
+
+#include <deque>
+#include <map>
+#include <vector>
+
 #include <fc/string.hpp>
 #include <fc/optional.hpp>
-#include <vector>
-#include <map>
+
 #include <fc/container/flat_fwd.hpp>
+#include <fc/container/deque_fwd.hpp>
 
 namespace fc {
   class value;
@@ -42,6 +47,14 @@ namespace fc {
          return n.c_str();  
      } 
   };
+  template<typename T> struct get_typename< std::deque<T> >
+  {
+     static const char* name()
+     {
+        static std::string n = std::string("std::deque<") + get_typename<T>::name() + ">"; 
+        return n.c_str();  
+     }
+  };
   template<typename T> struct get_typename<optional<T>>   
   { 
      static const char* name()  { 

include/fc/variant.hpp

@@ -9,6 +9,7 @@
 #include <map>
 #include <set>
 #include <fc/container/flat_fwd.hpp>
+#include <fc/container/deque_fwd.hpp>
 
 namespace fc
 {