adding fixed_string definition

include/fc/array.hpp

@@ -20,6 +20,10 @@ namespace fc {
     T&       at( size_t pos )      { assert( pos < N); return data[pos]; }
     const T& at( size_t pos )const { assert( pos < N); return data[pos]; }
     ///@}
+
+    T&       operator[]( size_t pos )      { assert( pos < N); return data[pos]; }
+    const T& operator[]( size_t pos )const { assert( pos < N); return data[pos]; }
+
     
     T*           begin()       {  return &data[0]; }
     const T*     begin()const  {  return &data[0]; }

include/fc/container/flat.hpp

@@ -30,8 +30,8 @@ namespace fc {
              value.insert( std::move(tmp) );
          }
        }
-       template<typename Stream, typename K, typename V>
+       template<typename Stream, typename K, typename... V>
-       inline void pack( Stream& s, const flat_map<K,V>& value ) {
+       inline void pack( Stream& s, const flat_map<K,V...>& value ) {
          pack( s, unsigned_int((uint32_t)value.size()) );
          auto itr = value.begin();
          auto end = value.end();
@@ -40,8 +40,8 @@ namespace fc {
            ++itr;
          }
        }
-       template<typename Stream, typename K, typename V>
+       template<typename Stream, typename K, typename V, typename... A>
-       inline void unpack( Stream& s, flat_map<K,V>& value ) 
+       inline void unpack( Stream& s, flat_map<K,V,A...>& value ) 
        {
          unsigned_int size; unpack( s, size );
          value.clear();
@@ -76,8 +76,8 @@ namespace fc {
          vo.insert( itr->as<T>() );
    }
 
-   template<typename K, typename T>
+   template<typename K, typename... T>
-   void to_variant( const flat_map<K, T>& var,  variant& vo )
+   void to_variant( const flat_map<K, T...>& var,  variant& vo )
    {
        std::vector< variant > vars(var.size());
        size_t i = 0;
@@ -85,8 +85,8 @@ namespace fc {
           vars[i] = fc::variant(*itr);
        vo = vars;
    }
-   template<typename K, typename T>
+   template<typename K, typename T, typename... A>
-   void from_variant( const variant& var,  flat_map<K, T>& vo )
+   void from_variant( const variant& var,  flat_map<K, T, A...>& vo )
    {
       const variants& vars = var.get_array();
       vo.clear();

include/fc/container/flat_fwd.hpp

@@ -12,10 +12,10 @@ namespace fc {
        void pack( Stream& s, const flat_set<T>& value );
        template<typename Stream, typename T>
        void unpack( Stream& s, flat_set<T>& value );
-       template<typename Stream, typename K, typename V>
+       template<typename Stream, typename K, typename... V>
-       void pack( Stream& s, const flat_map<K,V>& value );
+       void pack( Stream& s, const flat_map<K,V...>& value );
-       template<typename Stream, typename K, typename V>
+       template<typename Stream, typename K, typename... V>
-       void unpack( Stream& s, flat_map<K,V>& value ) ;
+       void unpack( Stream& s, flat_map<K,V...>& value ) ;
    } // namespace raw
 
 } // fc

include/fc/fixed_string.hpp

@@ -0,0 +1,159 @@
+#pragma once
+#include <fc/io/raw_fwd.hpp>
+#include <boost/multiprecision/cpp_int.hpp>
+
+
+namespace fc {
+    typedef boost::multiprecision::uint128_t  m128;
+
+
+   /**
+    *  This class is designed to offer in-place memory allocation of a string up to Length equal to
+    *  sizeof(Storage).  
+    *
+    *  The string will serialize the same way as std::string for variant and raw formats
+    *  The string will sort according to the comparison operators defined for Storage, this enables effecient
+    *  sorting.
+    */
+   template<typename Storage = std::pair<uint64_t,uint64_t> >
+   class fixed_string {
+      public:
+         fixed_string(){}
+         fixed_string( const fixed_string& c ):data(c.data){}
+
+         fixed_string( const std::string& str ) {
+            if( str.size() <= sizeof(data) )
+               memcpy( (char*)&data, str.c_str(), str.size() );
+            else {
+               wlog( "truncating string '${str}'", ("str",str) );
+               memcpy( (char*)&data, str.c_str(), sizeof(data) );
+            }
+         }
+         fixed_string( const char* str ) {
+            int l = strlen(str);
+            if( l <= sizeof(data) )
+               memcpy( (char*)&data, str, l );
+            else {
+               wlog( "truncating string '${str}'", ("str",str) );
+               memcpy( (char*)&data, str, sizeof(data) );
+            }
+         }
+
+         operator std::string()const { 
+            const char* self = (const char*)&data;
+            return std::string( self, self + size() );
+         }
+
+         uint32_t size()const {
+            if( *(((const char*)&data)+sizeof(data) - 1) )
+               return sizeof(data);
+            return strnlen( (const char*)&data, sizeof(data) );
+         }
+         uint32_t length()const { return size(); }
+
+         fixed_string& operator=( const fixed_string& str ) {
+            data = str.data;
+            return *this;
+         }
+         fixed_string& operator=( const char* str ) {
+            return *this = fixed_string(str);
+         }
+
+         fixed_string& operator=( const std::string& str ) {
+            if( str.size() <= sizeof(data) ) {
+               data = Storage();
+               memcpy( (char*)&data, str.c_str(), str.size() );
+            }
+            else {
+               wlog( "truncating string '${str}'", ("str",str) );
+               memcpy( (char*)&data, str.c_str(), sizeof(data) );
+            }
+            return *this;
+         }
+
+         friend std::string operator + ( const fixed_string& a, const std::string& b ) {
+            return std::string(a) + b;
+         }
+         friend std::string operator + ( const std::string& a, const fixed_string& b ) {
+            return a + std::string(b);
+         }
+
+         friend bool operator < ( const fixed_string& a, const fixed_string& b ) {
+            return a.data < b.data;
+         }
+         friend bool operator <= ( const fixed_string& a, const fixed_string& b ) {
+            return a.data <= b.data;
+         }
+         friend bool operator > ( const fixed_string& a, const fixed_string& b ) {
+            return a.data > b.data;
+         }
+         friend bool operator >= ( const fixed_string& a, const fixed_string& b ) {
+            return a.data >= b.data;
+         }
+         friend bool operator == ( const fixed_string& a, const fixed_string& b ) {
+            return a.data == b.data;
+         }
+         friend bool operator != ( const fixed_string& a, const fixed_string& b ) {
+            return a.data != b.data;
+         }
+      //private:
+         Storage data;
+   };
+
+  namespace raw
+  {
+    template<typename Stream, typename Storage>
+    inline void pack( Stream& s, const fc::fixed_string<Storage>& u ) { 
+       unsigned_int size = u.size();
+       pack( s, size );
+       s.write( (const char*)&u.data, size );
+    }
+
+    template<typename Stream, typename Storage>
+    inline void unpack( Stream& s, fc::fixed_string<Storage>& u ) { 
+       unsigned_int size; 
+       fc::raw::unpack( s, size );
+       if( size.value > 0 ) {
+          if( size.value > sizeof(Storage) ) {
+             s.read( (char*)&u.data, sizeof(Storage) );
+             s.skip( size.value - sizeof(Storage) );
+
+             /*
+             s.seekp( s.tellp() + (size.value - sizeof(Storage)) );
+             char tmp;
+             size.value -= sizeof(storage);
+             while( size.value ){ s.read( &tmp, 1 ); --size.value; }
+             */
+           //  s.skip( size.value - sizeof(Storage) );
+          } else {
+             s.read( (char*)&u.data, size.value );
+          }
+       }
+    }
+
+    /*
+    template<typename Stream, typename... Args>
+    inline void pack( Stream& s, const boost::multiprecision::number<Args...>& d ) {
+       s.write( (const char*)&d, sizeof(d) );
+    }
+
+    template<typename Stream, typename... Args>
+    inline void unpack( Stream& s, boost::multiprecision::number<Args...>& u ) { 
+       s.read( (const char*)&u, sizeof(u) );
+    }
+    */
+  }
+}
+
+#include <fc/variant.hpp>
+namespace fc {
+   template<typename Storage>
+   void to_variant( const fixed_string<Storage>& s, variant& v ) {
+      v = std::string(s);
+   }
+
+   template<typename Storage>
+   void from_variant( const variant& v, fixed_string<Storage>& s ) {
+      s = v.as_string();
+   }
+}

include/fc/io/raw_fwd.hpp

@@ -25,12 +25,19 @@ namespace fc {
    namespace ip { class endpoint; }
 
    namespace ecc { class public_key; class private_key; }
+   template<typename Storage> class fixed_string;
+
    namespace raw {
+    template<typename Stream, typename Storage> inline void pack( Stream& s, const fc::fixed_string<Storage>& u );
+    template<typename Stream, typename Storage> inline void unpack( Stream& s, fc::fixed_string<Storage>& u );
+
     template<typename Stream, typename IntType, typename EnumType>
     inline void pack( Stream& s, const fc::enum_type<IntType,EnumType>& tp );
     template<typename Stream, typename IntType, typename EnumType>
     inline void unpack( Stream& s, fc::enum_type<IntType,EnumType>& tp );
 
+
+
     template<typename Stream, typename T> inline void pack( Stream& s, const std::set<T>& value );
     template<typename Stream, typename T> inline void unpack( Stream& s, std::set<T>& value );
     template<typename Stream, typename T> inline void pack( Stream& s, const std::unordered_set<T>& value );
@@ -51,8 +58,8 @@ namespace fc {
     template<typename Stream, typename K, typename V> inline void pack( Stream& s, const std::map<K,V>& value );
     template<typename Stream, typename K, typename V> inline void unpack( Stream& s, std::map<K,V>& value );
 
-    template<typename Stream, typename K, typename V> inline void pack( Stream& s, const flat_map<K,V>& value );
+    template<typename Stream, typename K, typename... V> inline void pack( Stream& s, const flat_map<K,V...>& value );
-    template<typename Stream, typename K, typename V> inline void unpack( Stream& s, flat_map<K,V>& value );
+    template<typename Stream, typename K, typename V, typename... A> inline void unpack( Stream& s, flat_map<K,V,A...>& value );
 
     template<typename Stream, typename K, typename V> inline void pack( Stream& s, const std::pair<K,V>& value );
     template<typename Stream, typename K, typename V> inline void unpack( Stream& s, std::pair<K,V>& value );

include/fc/variant.hpp

@@ -88,10 +88,10 @@ namespace fc
    template<typename K, typename T>
    void from_variant( const variant& var,  std::unordered_map<K,T>& vo );
 
-   template<typename K, typename T>
+   template<typename K, typename... T>
-   void to_variant( const fc::flat_map<K,T>& var,  variant& vo );
+   void to_variant( const fc::flat_map<K,T...>& var,  variant& vo );
-   template<typename K, typename T>
+   template<typename K, typename... T>
-   void from_variant( const variant& var, fc::flat_map<K,T>& vo );
+   void from_variant( const variant& var, fc::flat_map<K,T...>& vo );
 
    template<typename T>
    void to_variant( const std::map<string,T>& var,  variant& vo );

src/thread/context.hpp

@@ -4,6 +4,8 @@
 #include <fc/exception/exception.hpp>
 #include <vector>
 
+#include <iostream>
+
 #include <boost/version.hpp>
 
 #if BOOST_VERSION >= 105400
@@ -43,12 +45,17 @@ namespace fc {
   struct context  {
     typedef fc::context* ptr;
 
-#if BOOST_VERSION >= 105400
+#if BOOST_VERSION >= 105400 // && BOOST_VERSION <= 106100 
     bco::stack_context stack_ctx;
 #endif
 
+#if BOOST_VERSION >= 106100 
+    typedef bc::detail::transfer_t transfer_t;
+#else
+    typedef intptr_t transfer_t;
+#endif
 
-    context( void (*sf)(intptr_t), stack_allocator& alloc, fc::thread* t )
+    context( void (*sf)(transfer_t), stack_allocator& alloc, fc::thread* t )
     : caller_context(0),
       stack_alloc(&alloc),
       next_blocked(0), 
@@ -63,7 +70,13 @@ namespace fc {
       cur_task(0),
       context_posted_num(0)
     {
-#if BOOST_VERSION >= 105600
+#if BOOST_VERSION >= 106100
+     //  std::cerr<< "HERE: "<< BOOST_VERSION <<"\n";
+     //my_context = new bc::execution_context<intptr_t>( [=]( bc::execution_context<intptr_t> sink, intptr_t self  ){ std::cerr<<"in ex\n"; sf(self);  std::cerr<<"exit ex\n"; return sink; } );
+     size_t stack_size = FC_CONTEXT_STACK_SIZE;
+     alloc.allocate(stack_ctx, stack_size);
+     my_context = bc::detail::make_fcontext( stack_ctx.sp, stack_ctx.size, sf );
+#elif BOOST_VERSION >= 105600
      size_t stack_size = FC_CONTEXT_STACK_SIZE;
      alloc.allocate(stack_ctx, stack_size);
      my_context = bc::make_fcontext( stack_ctx.sp, stack_ctx.size, sf); 
@@ -84,7 +97,7 @@ namespace fc {
     }
 
     context( fc::thread* t) :
-#if BOOST_VERSION >= 105600
+#if BOOST_VERSION >= 105600 && BOOST_VERSION <= 106100 
      my_context(nullptr),
 #elif BOOST_VERSION >= 105300
      my_context(new bc::fcontext_t),
@@ -102,10 +115,21 @@ namespace fc {
      complete(false),
      cur_task(0),
      context_posted_num(0)
-    {}
+    {
+    
+#if BOOST_VERSION >= 106100
+       /*
+        bc::execution_context<intptr_t> tmp(  [=]( bc::execution_context<intptr_t> sink, intptr_t ) { std::cerr<<"get current\n"; return sink; } );
+        auto result = tmp(0);
+        my_context = new bc::execution_context<intptr_t>( std::move( std::get<0>(result) ) );
+        */
+#endif
+    }
 
     ~context() {
-#if BOOST_VERSION >= 105600
+#if BOOST_VERSION >= 106100
+      // delete my_context;
+#elif BOOST_VERSION >= 105600
       if(stack_alloc)
         stack_alloc->deallocate( stack_ctx );
 #elif BOOST_VERSION >= 105400
@@ -209,7 +233,11 @@ namespace fc {
 
 
 
-#if BOOST_VERSION >= 105300 && BOOST_VERSION < 105600
+
+#if BOOST_VERSION >= 106100 
+    //bc::execution_context<intptr_t>*   my_context;
+    bc::detail::fcontext_t       my_context;
+#elif BOOST_VERSION >= 105300 && BOOST_VERSION < 105600
     bc::fcontext_t*              my_context;
 #else
     bc::fcontext_t               my_context;

src/thread/thread_d.hpp

@@ -18,6 +18,8 @@ namespace fc {
     class thread_d {
 
         public:
+           fc::context* prev_ctx = nullptr;
+
            thread_d(fc::thread& s)
             :self(s), boost_thread(0),
              task_in_queue(0),
@@ -397,7 +399,12 @@ namespace fc {
                 }
                 // slog( "jump to %p from %p", next, prev );
                 // fc_dlog( logger::get("fc_context"), "from ${from} to ${to}", ( "from", int64_t(prev) )( "to", int64_t(next) ) ); 
-#if BOOST_VERSION >= 105600
+#if BOOST_VERSION >= 106100
+                prev_ctx = prev;
+                std::cerr<<"start jumping to existing context...\n";
+                bc::detail::jump_fcontext( next->my_context, this );
+                std::cerr<<"back from jumping to existing context\n";
+#elif BOOST_VERSION >= 105600
                 bc::jump_fcontext( &prev->my_context, next->my_context, 0 );
 #elif BOOST_VERSION >= 105300
                 bc::jump_fcontext( prev->my_context, next->my_context, 0 );
@@ -439,7 +446,16 @@ namespace fc {
 
                 // slog( "jump to %p from %p", next, prev );
                 // fc_dlog( logger::get("fc_context"), "from ${from} to ${to}", ( "from", int64_t(prev) )( "to", int64_t(next) ) );
-#if BOOST_VERSION >= 105600
+#if BOOST_VERSION >= 106100
+                //(*next->my_context)( (intptr_t)this );
+                //bc::detail::transfer_t tran; tran.data = this;
+                std::cerr << "start prev->my_context = " << prev->my_context <<"... \n";
+                std::cerr << "jumping to next context... \n";
+                prev_ctx = prev;
+                auto result = bc::detail::jump_fcontext( next->my_context, this );
+                std::cerr << "end prev->my_context = " << prev->my_context <<"... \n";
+                std::cerr << result.fctx <<" <--- result \n";
+#elif BOOST_VERSION >= 105600
                 bc::jump_fcontext( &prev->my_context, next->my_context, (intptr_t)this );
 #elif BOOST_VERSION >= 105300
                 bc::jump_fcontext( prev->my_context, next->my_context, (intptr_t)this );
@@ -467,9 +483,22 @@ namespace fc {
               return true;
            }
 
-           static void start_process_tasks( intptr_t my ) 
+           static void start_process_tasks( fc::context::transfer_t my ) 
            {
+#if BOOST_VERSION >= 106100
+              std::cerr<<"my data: "<<my.data<<"\n";
+              std::cerr<<"my from: "<<my.fctx<<"\n";
+              thread_d* self = (thread_d*)my.data;
+              if( self->prev_ctx )
+              {
+                 std::cerr << "setting prev_ctx to " << int64_t(my.fctx) << "\n";
+                 self->prev_ctx->my_context = my.fctx;
+              }
+              std::cerr<<"start process tasks\n" << int64_t(self)<<"\n";
+              assert( self != 0 );
+#else
               thread_d* self = (thread_d*)my;
+#endif
               try 
               {
                 self->process_tasks();
@@ -484,6 +513,7 @@ namespace fc {
               }
               self->free_list.push_back(self->current);
               self->start_next_fiber( false );
+              std::cerr << "existing start process tasks \n ";
            }
 
            void run_next_task() 

tests/network/ntp_test.cpp

@@ -8,6 +8,10 @@ BOOST_AUTO_TEST_SUITE(fc_network)
 
 BOOST_AUTO_TEST_CASE( ntp_test )
 {
+   ilog("start ntp test");
+   fc::usleep( fc::seconds(1) );
+   ilog("done ntp test");
+   /*
    fc::ntp ntp_service;
    ntp_service.set_request_interval(5);
    fc::usleep(fc::seconds(4) );
@@ -20,6 +24,7 @@ BOOST_AUTO_TEST_CASE( ntp_test )
 //   auto seconds = delta.count() / 1000000;
    auto msec= delta.count() / 1000;
    BOOST_CHECK( msec < 100 );
+   */
 }
 
 BOOST_AUTO_TEST_SUITE_END()