addding improved support for serializing boost interprocss types

include/fc/container/flat.hpp

@@ -54,6 +54,35 @@ namespace fc {
              value.insert( std::move(tmp) );
          }
        }
+
+       template<typename Stream, typename T, typename A>
+       void pack( Stream& s, const bip::vector<T,A>& value ) {
+         pack( s, unsigned_int((uint32_t)value.size()) );
+         if( !std::is_fundamental<T>::value ) {
+            auto itr = value.begin();
+            auto end = value.end();
+            while( itr != end ) {
+              fc::raw::pack( s, *itr );
+              ++itr;
+            }
+         } else {
+             s.write( (const char*)value.data(), value.size() );
+         }
+       }
+
+       template<typename Stream, typename T, typename A>
+       void unpack( Stream& s, bip::vector<T,A>& value ) {
+          unsigned_int size;
+          unpack( s, size );
+          value.resize( size );
+          if( !std::is_fundamental<T>::value ) {
+             for( auto& item : value )
+                unpack( s, item );
+          } else {
+             s.read( (char*)value.data(), value.size() );
+          }
+       }
+
    } // namespace raw
 
 

include/fc/container/flat_fwd.hpp

@@ -1,11 +1,13 @@
 #pragma once 
 #include <boost/container/flat_map.hpp>
 #include <boost/container/flat_set.hpp>
+#include <boost/interprocess/containers/vector.hpp>
 
 namespace fc {
 
    using boost::container::flat_map;
    using boost::container::flat_set;
+   namespace bip = boost::interprocess;
 
    namespace raw {
        template<typename Stream, typename T>
@@ -16,6 +18,12 @@ namespace fc {
        void pack( Stream& s, const flat_map<K,V...>& value );
        template<typename Stream, typename K, typename... V>
        void unpack( Stream& s, flat_map<K,V...>& value ) ;
+
+
+       template<typename Stream, typename T, typename A>
+       void pack( Stream& s, const bip::vector<T,A>& value );
+       template<typename Stream, typename T, typename A>
+       void unpack( Stream& s, bip::vector<T,A>& value );
    } // namespace raw
 
 } // fc

include/fc/variant.hpp

@@ -312,6 +312,12 @@ namespace fc
            return tmp;
         }
 
+        template<typename T>
+        void as( T& v )const
+        {
+           from_variant( *this, v );
+        }
+
         variant& operator=( variant&& v );
         variant& operator=( const variant& v );