[GRPH-92] Build optimization

include/fc/exception/exception.hpp

@@ -5,6 +5,7 @@
  */
 #include <fc/log/logger.hpp>
 #include <fc/optional.hpp>
+#include <fc/utility.hpp>
 #include <exception>
 #include <functional>
 #include <unordered_map>
@@ -222,81 +223,97 @@ namespace fc
    }();  \
 
 
-#define FC_DECLARE_DERIVED_EXCEPTION( TYPE, BASE, CODE, WHAT ) \
+#define FC_DECLARE_DERIVED_EXCEPTION( TYPE, BASE, CODE ) \
    class TYPE : public BASE  \
    { \
       public: \
        enum code_enum { \
           code_value = CODE, \
        }; \
-       explicit TYPE( int64_t code, const std::string& name_value, const std::string& what_value ) \
-       :BASE( code, name_value, what_value ){} \
-       explicit TYPE( fc::log_message&& m, int64_t code, const std::string& name_value, const std::string& what_value ) \
-       :BASE( std::move(m), code, name_value, what_value ){} \
-       explicit TYPE( fc::log_messages&& m, int64_t code, const std::string& name_value, const std::string& what_value )\
-       :BASE( std::move(m), code, name_value, what_value ){}\
-       explicit TYPE( const fc::log_messages& m, int64_t code, const std::string& name_value, const std::string& what_value )\
-       :BASE( m, code, name_value, what_value ){}\
-       TYPE( const std::string& what_value, const fc::log_messages& m ) \
-       :BASE( m, CODE, BOOST_PP_STRINGIZE(TYPE), what_value ){} \
-       TYPE( fc::log_message&& m ) \
-       :BASE( fc::move(m), CODE, BOOST_PP_STRINGIZE(TYPE), WHAT ){}\
-       TYPE( fc::log_messages msgs ) \
-       :BASE( fc::move( msgs ), CODE, BOOST_PP_STRINGIZE(TYPE), WHAT ) {} \
-       TYPE( const TYPE& c ) \
-       :BASE(c){} \
-       TYPE( const BASE& c ) \
-       :BASE(c){} \
-       TYPE():BASE(CODE, BOOST_PP_STRINGIZE(TYPE), WHAT){}\
+       explicit TYPE( int64_t code, const std::string& name_value, const std::string& what_value ); \
+       explicit TYPE( fc::log_message&& m, int64_t code, const std::string& name_value, const std::string& what_value ); \
+       explicit TYPE( fc::log_messages&& m, int64_t code, const std::string& name_value, const std::string& what_value );\
+       explicit TYPE( const fc::log_messages& m, int64_t code, const std::string& name_value, const std::string& what_value );\
+       explicit TYPE( const std::string& what_value, const fc::log_messages& m ); \
+       explicit TYPE( fc::log_message&& m ); \
+       explicit TYPE( fc::log_messages msgs ); \
+       TYPE( TYPE&& c ) = default; \
+       TYPE( const TYPE& c ); \
+       TYPE( const BASE& c ); \
+       explicit TYPE();\
        \
-       virtual std::shared_ptr<fc::exception> dynamic_copy_exception()const\
-       { return std::make_shared<TYPE>( *this ); } \
-       virtual NO_RETURN void     dynamic_rethrow_exception()const \
-       { if( code() == CODE ) throw *this;\
-         else fc::exception::dynamic_rethrow_exception(); \
-       } \
+       virtual std::shared_ptr<fc::exception> dynamic_copy_exception()const;\
+       virtual NO_RETURN void dynamic_rethrow_exception()const; \
    };
 
-  #define FC_DECLARE_EXCEPTION( TYPE, CODE, WHAT ) \
-      FC_DECLARE_DERIVED_EXCEPTION( TYPE, fc::exception, CODE, WHAT )
+#define FC_IMPLEMENT_DERIVED_EXCEPTION( TYPE, BASE, CODE, WHAT ) \
+   TYPE::TYPE( int64_t code, const std::string& name_value, const std::string& what_value ) \
+      : BASE( code, name_value, what_value ) {} \
+   TYPE::TYPE( fc::log_message&& m, int64_t code, const std::string& name_value, const std::string& what_value ) \
+      : BASE( std::move(m), code, name_value, what_value ) {} \
+   TYPE::TYPE( fc::log_messages&& m, int64_t code, const std::string& name_value, const std::string& what_value ) \
+      : BASE( std::move(m), code, name_value, what_value ) {} \
+   TYPE::TYPE( const fc::log_messages& m, int64_t code, const std::string& name_value, const std::string& what_value ) \
+      : BASE( m, code, name_value, what_value ) {} \
+   TYPE::TYPE( const std::string& what_value, const fc::log_messages& m ) \
+      : BASE( m, CODE, BOOST_PP_STRINGIZE(TYPE), what_value ) {} \
+   TYPE::TYPE( fc::log_message&& m ) \
+      : BASE( std::move(m), CODE, BOOST_PP_STRINGIZE(TYPE), WHAT ) {} \
+   TYPE::TYPE( fc::log_messages msgs ) \
+      : BASE( std::move( msgs ), CODE, BOOST_PP_STRINGIZE(TYPE), WHAT ) {} \
+   TYPE::TYPE( const TYPE& c ) : BASE(c) {} \
+   TYPE::TYPE( const BASE& c ) : BASE(c) {} \
+   TYPE::TYPE() : BASE(CODE, BOOST_PP_STRINGIZE(TYPE), WHAT) {} \
+   \
+   std::shared_ptr<fc::exception> TYPE::dynamic_copy_exception()const \
+   { \
+      return std::make_shared<TYPE>( *this ); \
+   } \
+   NO_RETURN void TYPE::dynamic_rethrow_exception()const \
+   { \
+      if( code() == CODE ) throw *this;\
+      else fc::exception::dynamic_rethrow_exception(); \
+   }
+
+#define FC_DECLARE_EXCEPTION( TYPE, CODE ) \
+      FC_DECLARE_DERIVED_EXCEPTION( TYPE, fc::exception, CODE )
+
+#define FC_IMPLEMENT_EXCEPTION( TYPE, CODE, WHAT ) \
+   FC_IMPLEMENT_DERIVED_EXCEPTION( TYPE, fc::exception, CODE, WHAT )
 
-  FC_DECLARE_EXCEPTION( timeout_exception, timeout_exception_code, "Timeout" );
-  FC_DECLARE_EXCEPTION( file_not_found_exception, file_not_found_exception_code, "File Not Found" );
+  FC_DECLARE_EXCEPTION( timeout_exception, timeout_exception_code );
+  FC_DECLARE_EXCEPTION( file_not_found_exception, file_not_found_exception_code );
   /**
-   * @brief report's parse errors
+   * @brief reports parse errors
    */
-  FC_DECLARE_EXCEPTION( parse_error_exception, parse_error_exception_code, "Parse Error" );
-  FC_DECLARE_EXCEPTION( invalid_arg_exception, invalid_arg_exception_code, "Invalid Argument" );
+  FC_DECLARE_EXCEPTION( parse_error_exception, parse_error_exception_code );
+  FC_DECLARE_EXCEPTION( invalid_arg_exception, invalid_arg_exception_code );
   /**
    * @brief reports when a key, guid, or other item is not found.
    */
-  FC_DECLARE_EXCEPTION( key_not_found_exception, key_not_found_exception_code, "Key Not Found" );
-  FC_DECLARE_EXCEPTION( bad_cast_exception, bad_cast_exception_code, "Bad Cast" );
-  FC_DECLARE_EXCEPTION( out_of_range_exception, out_of_range_exception_code, "Out of Range" );
+  FC_DECLARE_EXCEPTION( key_not_found_exception, key_not_found_exception_code );
+  FC_DECLARE_EXCEPTION( bad_cast_exception, bad_cast_exception_code );
+  FC_DECLARE_EXCEPTION( out_of_range_exception, out_of_range_exception_code );
 
   /** @brief if an operation is unsupported or not valid this may be thrown */
-  FC_DECLARE_EXCEPTION( invalid_operation_exception,
-                        invalid_operation_exception_code,
-                        "Invalid Operation" );
+  FC_DECLARE_EXCEPTION( invalid_operation_exception, invalid_operation_exception_code );
   /** @brief if an host name can not be resolved this may be thrown */
-  FC_DECLARE_EXCEPTION( unknown_host_exception,
-                         unknown_host_exception_code,
-                         "Unknown Host" );
+  FC_DECLARE_EXCEPTION( unknown_host_exception, unknown_host_exception_code );
 
   /**
    *  @brief used to report a canceled Operation
    */
-  FC_DECLARE_EXCEPTION( canceled_exception, canceled_exception_code, "Canceled" );
+  FC_DECLARE_EXCEPTION( canceled_exception, canceled_exception_code );
   /**
    *  @brief used inplace of assert() to report violations of pre conditions.
    */
-  FC_DECLARE_EXCEPTION( assert_exception, assert_exception_code, "Assert Exception" );
-  FC_DECLARE_EXCEPTION( eof_exception, eof_exception_code, "End Of File" );
-  FC_DECLARE_EXCEPTION( null_optional, null_optional_code, "null optional" );
-  FC_DECLARE_EXCEPTION( aes_exception, aes_error_code, "AES error" );
-  FC_DECLARE_EXCEPTION( overflow_exception, overflow_code, "Integer Overflow" );
-  FC_DECLARE_EXCEPTION( underflow_exception, underflow_code, "Integer Underflow" );
-  FC_DECLARE_EXCEPTION( divide_by_zero_exception, divide_by_zero_code, "Integer Divide By Zero" );
+  FC_DECLARE_EXCEPTION( assert_exception, assert_exception_code );
+  FC_DECLARE_EXCEPTION( eof_exception, eof_exception_code );
+  FC_DECLARE_EXCEPTION( null_optional, null_optional_code );
+  FC_DECLARE_EXCEPTION( aes_exception, aes_error_code );
+  FC_DECLARE_EXCEPTION( overflow_exception, overflow_code );
+  FC_DECLARE_EXCEPTION( underflow_exception, underflow_code );
+  FC_DECLARE_EXCEPTION( divide_by_zero_exception, divide_by_zero_code );
 
   std::string except_str();
 

include/fc/io/raw.hpp

@@ -616,14 +616,12 @@ namespace fc {
     }
 
 
-
     template<typename Stream, typename T>
-    inline void pack( Stream& s, const T& v, uint32_t _max_depth ) {
-       FC_ASSERT( _max_depth > 0 );
-       fc::raw::detail::if_reflected< typename fc::reflector<T>::is_defined >::pack( s, v, _max_depth - 1 );
+    void pack( Stream& s, const T& v ) {
+      fc::raw::detail::if_reflected< typename fc::reflector<T>::is_defined >::pack(s,v);
     }
     template<typename Stream, typename T>
-    inline void unpack( Stream& s, T& v, uint32_t _max_depth )
+    void unpack( Stream& s, T& v )
     { try {
        FC_ASSERT( _max_depth > 0 );
        fc::raw::detail::if_reflected< typename fc::reflector<T>::is_defined >::unpack( s, v, _max_depth - 1 );

include/fc/network/ip.hpp

@@ -82,14 +82,14 @@ namespace fc {
 
   namespace raw
   {
-    template<typename Stream>
-    inline void pack( Stream& s, const ip::address& v, uint32_t _max_depth=FC_PACK_MAX_DEPTH )
+    template<typename Stream> 
+    void pack( Stream& s, const ip::address& v )
     {
        FC_ASSERT( _max_depth > 0 );
        fc::raw::pack( s, uint32_t(v), _max_depth - 1 );
     }
-    template<typename Stream>
-    inline void unpack( Stream& s, ip::address& v, uint32_t _max_depth=FC_PACK_MAX_DEPTH )
+    template<typename Stream> 
+    void unpack( Stream& s, ip::address& v )
     {
        FC_ASSERT( _max_depth > 0 );
        uint32_t _ip;
@@ -119,8 +119,9 @@ namespace fc {
 
   }
 } // namespace fc
-FC_REFLECT_TYPENAME( fc::ip::address )
-FC_REFLECT_TYPENAME( fc::ip::endpoint )
+
+FC_REFLECT_EMPTY( fc::ip::address )
+FC_REFLECT_TYPENAME( fc::ip::endpoint ) 
 namespace std
 {
     template<>

include/fc/rpc/websocket_api.hpp

@@ -10,7 +10,7 @@ namespace fc { namespace rpc {
    class websocket_api_connection : public api_connection
    {
       public:
-         websocket_api_connection( const std::shared_ptr<fc::http::websocket_connection> &c, uint32_t max_conversion_depth );
+         websocket_api_connection( fc::http::websocket_connection& c, uint32_t max_conversion_depth );
          ~websocket_api_connection();
 
          virtual variant send_call(
@@ -29,7 +29,7 @@ namespace fc { namespace rpc {
             const std::string& message,
             bool send_message = true );
 
-         std::shared_ptr<fc::http::websocket_connection>  _connection;
+         fc::http::websocket_connection&  _connection;
          fc::rpc::state                   _rpc_state;
    };
 

src/exception.cpp

@@ -8,6 +8,24 @@
 
 namespace fc
 {
+   FC_IMPLEMENT_EXCEPTION( timeout_exception, timeout_exception_code, "Timeout" )
+   FC_IMPLEMENT_EXCEPTION( file_not_found_exception, file_not_found_exception_code, "File Not Found" )
+   FC_IMPLEMENT_EXCEPTION( parse_error_exception, parse_error_exception_code, "Parse Error" )
+   FC_IMPLEMENT_EXCEPTION( invalid_arg_exception, invalid_arg_exception_code, "Invalid Argument" )
+   FC_IMPLEMENT_EXCEPTION( key_not_found_exception, key_not_found_exception_code, "Key Not Found" )
+   FC_IMPLEMENT_EXCEPTION( bad_cast_exception, bad_cast_exception_code, "Bad Cast" )
+   FC_IMPLEMENT_EXCEPTION( out_of_range_exception, out_of_range_exception_code, "Out of Range" )
+   FC_IMPLEMENT_EXCEPTION( invalid_operation_exception, invalid_operation_exception_code, "Invalid Operation" )
+   FC_IMPLEMENT_EXCEPTION( unknown_host_exception, unknown_host_exception_code, "Unknown Host" )
+   FC_IMPLEMENT_EXCEPTION( canceled_exception, canceled_exception_code, "Canceled" )
+   FC_IMPLEMENT_EXCEPTION( assert_exception, assert_exception_code, "Assert Exception" )
+   FC_IMPLEMENT_EXCEPTION( eof_exception, eof_exception_code, "End Of File" )
+   FC_IMPLEMENT_EXCEPTION( null_optional, null_optional_code, "null optional" )
+   FC_IMPLEMENT_EXCEPTION( aes_exception, aes_error_code, "AES error" )
+   FC_IMPLEMENT_EXCEPTION( overflow_exception, overflow_code, "Integer Overflow" )
+   FC_IMPLEMENT_EXCEPTION( underflow_exception, underflow_code, "Integer Underflow" )
+   FC_IMPLEMENT_EXCEPTION( divide_by_zero_exception, divide_by_zero_code, "Integer Divide By Zero" )
+
    FC_REGISTER_EXCEPTIONS( (timeout_exception)
                            (file_not_found_exception)
                            (parse_error_exception)

src/rpc/cli.cpp

@@ -121,6 +121,11 @@ void cli::run()
       catch ( const fc::exception& e )
       {
          std::cout << e.to_detail_string() << "\n";
+
+         if (e.code() == fc::canceled_exception_code)
+         {
+            break;
+         }
       }
    }
 }

src/rpc/websocket_api.cpp

@@ -7,10 +7,9 @@ websocket_api_connection::~websocket_api_connection()
 {
 }
 
-websocket_api_connection::websocket_api_connection( const std::shared_ptr<fc::http::websocket_connection>& c, uint32_t max_depth )
+websocket_api_connection::websocket_api_connection( fc::http::websocket_connection& c, uint32_t max_depth )
    : api_connection(max_depth),_connection(c)
 {
-   FC_ASSERT( c );
    _rpc_state.add_method( "call", [this]( const variants& args ) -> variant
    {
       FC_ASSERT( args.size() == 3 && args[2].is_array() );
@@ -48,50 +47,39 @@ websocket_api_connection::websocket_api_connection( const std::shared_ptr<fc::ht
       return this->receive_call( 0, method_name, args );
    } );
 
-   _connection->on_message_handler( [&]( const std::string& msg ){ on_message(msg,true); } );
-   _connection->on_http_handler( [&]( const std::string& msg ){ return on_message(msg,false); } );
-   _connection->closed.connect( [this](){ closed(); } );
+   _connection.on_message_handler( [&]( const std::string& msg ){ on_message(msg,true); } );
+   _connection.on_http_handler( [&]( const std::string& msg ){ return on_message(msg,false); } );
+   _connection.closed.connect( [this](){ closed(); } );
 }
 
 variant websocket_api_connection::send_call(
    api_id_type api_id,
    string method_name,
    variants args /* = variants() */ )
 {
-   if( _connection )
-   {
-      auto request = _rpc_state.start_remote_call(  "call", {api_id, std::move(method_name), std::move(args) } );
-      _connection->send_message( fc::json::to_string(fc::variant(request, _max_conversion_depth),
+   auto request = _rpc_state.start_remote_call(  "call", {api_id, std::move(method_name), std::move(args) } );
+   _connection.send_message( fc::json::to_string(fc::variant(request, _max_conversion_depth),
                                                  fc::json::stringify_large_ints_and_doubles, _max_conversion_depth ) );
-      return _rpc_state.wait_for_response( *request.id );
-   }
-   return variant();
+   return _rpc_state.wait_for_response( *request.id );
 }
 
 variant websocket_api_connection::send_callback(
    uint64_t callback_id,
    variants args /* = variants() */ )
 {
-   if( _connection )
-   {
-      auto request = _rpc_state.start_remote_call( "callback", {callback_id, std::move(args) } );
-      _connection->send_message( fc::json::to_string(fc::variant(request, _max_conversion_depth),
+   auto request = _rpc_state.start_remote_call( "callback", {callback_id, std::move(args) } );
+   _connection.send_message( fc::json::to_string(fc::variant(request, _max_conversion_depth),
                                                  fc::json::stringify_large_ints_and_doubles, _max_conversion_depth ) );
-      return _rpc_state.wait_for_response( *request.id );
-   }
-   return variant();
+   return _rpc_state.wait_for_response( *request.id );
 }
 
 void websocket_api_connection::send_notice(
    uint64_t callback_id,
    variants args /* = variants() */ )
 {
-   if( _connection )
-   {
-      fc::rpc::request req{ optional<uint64_t>(), "notice", {callback_id, std::move(args)}};
-      _connection->send_message( fc::json::to_string(fc::variant(req, _max_conversion_depth),
+   fc::rpc::request req{ optional<uint64_t>(), "notice", {callback_id, std::move(args)}};
+   _connection.send_message( fc::json::to_string(fc::variant(req, _max_conversion_depth),
                                                  fc::json::stringify_large_ints_and_doubles, _max_conversion_depth ) );
-   }
 }
 
 std::string websocket_api_connection::on_message(
@@ -129,8 +117,8 @@ std::string websocket_api_connection::on_message(
                if( call.id )
                {
                   auto reply = fc::json::to_string( response( *call.id, result, "2.0" ), fc::json::stringify_large_ints_and_doubles, _max_conversion_depth );
-                  if( send_message && _connection )
-                     _connection->send_message( reply );
+                  if( send_message )
+                     _connection.send_message( reply );
                   return reply;
                }
             }
@@ -147,8 +135,8 @@ std::string websocket_api_connection::on_message(
 
                auto reply = fc::json::to_string( variant(response( *call.id, error_object{ 1, optexcept->to_string(), fc::variant(*optexcept, _max_conversion_depth)}, "2.0" ), _max_conversion_depth ),
                                                  fc::json::stringify_large_ints_and_doubles, _max_conversion_depth );
-               if( send_message && _connection )
-                  _connection->send_message( reply );
+               if( send_message )
+                  _connection.send_message( reply );
 
                return reply;
          }

src/thread/thread.cpp

@@ -110,7 +110,7 @@ namespace fc {
 
    thread::~thread() {
       //wlog( "my ${n}", ("n",name()) );
-      if( my )
+      if( my && is_running() )
       {
         // wlog( "calling quit() on ${n}",("n",my->name) );
         quit(); // deletes `my`
@@ -333,6 +333,10 @@ namespace fc {
 
    void thread::async_task( task_base* t, const priority& p, const time_point& tp ) {
       assert(my);
+      if( !is_running() )
+      {
+         FC_THROW_EXCEPTION( canceled_exception, "Thread is not running.");
+      }
       t->_when = tp;
      // slog( "when %lld", t->_when.time_since_epoch().count() );
      // slog( "delay %lld", (tp - fc::time_point::now()).count() );