Merge pull request EOSIO#136 from EOSIO/feature/contract_datastream

Feature/contract datastream

examples/abigen_test/CMakeLists.txt

@@ -4,4 +4,4 @@ project(abigen_test_example VERSION 1.0.0)
 find_package(eosio.cdt)
 
 ### generate both the wasm and abi
-add_eosio_cdt_executable( test test.cpp )
+add_contract( abitest abitest abitest.cpp )

examples/abigen_test/test.cpp → examples/abigen_test/abitest.cpp

@@ -1,5 +1,5 @@
 #include <eosiolib/eosio.hpp>
-#include <eosiolib/optional.hpp>
+#include <optional>
 
 using namespace eosio;
 
@@ -11,7 +11,7 @@ namespace test {
       void printddd() { print("testa"); }
       int fielda;
       float fieldb;
-      account_name name;
+      capi_name name;
    };
 
    struct testb {
@@ -24,24 +24,23 @@ namespace test {
    };
 }
 
-class test_contract : public eosio::contract {
+CONTRACT abitest : public eosio::contract {
   public:
       using contract::contract;
 
       // mark this method as an action and specify the name explicity
       [[ eosio::action("testacta") ]]
-      void testact_a( account_name user, const std::string& s, std::vector<int>& c, std::vector<std::string> sv ) {
+      void testact_a( name user, const std::string& s, std::vector<int>& c, std::vector<std::string> sv ) {
          print( "Hello, ", name{user} );
       }
 
       // mark this method as an action
-      [[ eosio::action ]]
-      void testactb( test::test_c input, type_def td, optional<int> cc, bool d ) {
+      ACTION testactb( test::test_c input, type_def td, std::optional<int> cc, bool d ) {
          print(input.num);
       }
 
       // mark this struct as a table and allow multi_index typedefs to define the tables
-      struct [[eosio::table]] testtable {
+      TABLE testtable {
          uint64_t owner;
          uint64_t third;
          uint64_t primary_key() const { return owner; }
@@ -56,9 +55,10 @@ class test_contract : public eosio::contract {
       };
 };
 
-typedef eosio::multi_index< N(testtab), test_contract::testtable > testtable_t;
-typedef eosio::multi_index< N(testtaba), test_contract::testtable > testtable_a_t;
-typedef eosio::multi_index< N(testtab2), test_contract::test_table2 > testtable2_t;
+typedef eosio::multi_index< "testtab"_n,  abitest::testtable > testtable_t;
+typedef eosio::multi_index< "testtaba"_n, abitest::testtable > testtable_a_t;
+typedef eosio::multi_index< "testtab2"_n, abitest::test_table2 > testtable2_t;
 
 // NOTE THIS IS A TEST CONTRACT AND WILL NOT WORK CORRECTLY, the action `testa` will not be in the dispatcher of this macro
-EOSIO_ABI( test_contract, (testact_a)(testactb) )
+extern "C" 
+void apply(uint64_t, uint64_t, uint64_t){}

examples/hello/CMakeLists.txt

@@ -7,4 +7,4 @@ find_package(eosio.cdt)
 #add_executable( hello.wasm hello.cpp )
 
 ### Generate the wasm and abi
-add_eosio_cdt_executable( hello hello.cpp )
+add_contract( hello hello hello.cpp )

examples/hello/hello.cpp

@@ -1,13 +1,14 @@
 #include <eosiolib/eosio.hpp>
+
 using namespace eosio;
-class hello : public eosio::contract {
+
+CONTRACT hello : public eosio::contract {
   public:
       using contract::contract;
 
-      [[eosio::action]]
-      void hi( account_name user ) {
+      ACTION hi( name user ) {
          print( "Hello, ", name{user} );
       }
 };
 
-EOSIO_ABI( hello, (hi) )
+EOSIO_DISPATCH( hello, (hi) )

examples/template/CMakeLists.txt

@@ -2,3 +2,6 @@ cmake_minimum_required(VERSION 3.5)
 project(template_example VERSION 1.0.0)
 
 find_package(eosio.cdt)
+
+# add contract
+add_contract( <contract name>, <target name>, <source files....> )

libraries/eosiolib/CMakeLists.txt

@@ -18,4 +18,3 @@ install(TARGETS eosio EXPORT EosioLib
 file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/../eosiolib DESTINATION ${CMAKE_BINARY_DIR}/include FILES_MATCHING PATTERN "*.h" PATTERN "*.hpp")
 add_custom_command( TARGET eosio POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy $<TARGET_FILE:eosio> ${CMAKE_BINARY_DIR}/lib )
 install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/../eosiolib DESTINATION ${CMAKE_INSTALL_FULL_INCLUDEDIR} FILES_MATCHING PATTERN "*.h" PATTERN "*.hpp")
-install(FILES ${CMAKE_CURRENT_BINARY_DIR}/core_symbol.hpp DESTINATION ${CMAKE_INSTALL_FULL_INCLUDEDIR}/eosiolib)

libraries/eosiolib/action.hpp

@@ -191,14 +191,14 @@ namespace eosio {
        *
        * @brief Name of the account the action is intended for
        */
-      name                       code_account;
+      name                       account;
 
       /**
        * Name of the action
        *
        * @brief Name of the action
        */
-      name                       action_name;
+      name                       name;
 
       /**
        * List of permissions that authorize this action
@@ -232,8 +232,8 @@ namespace eosio {
        * @param value - The action struct that will be serialized via pack into data
        */
       template<typename T>
-      action( const permission_level& auth, name a, name n, T&& value )
-      :code_account(a), action_name(n), authorization(1,auth), data(pack(std::forward<T>(value))) {}
+      action( const permission_level& auth, struct name a, struct name n, T&& value )
+      :account(a), name(n), authorization(1,auth), data(pack(std::forward<T>(value))) {}
 
       /**
        * Construct a new action object with the given action struct
@@ -246,10 +246,10 @@ namespace eosio {
        * @param value - The action struct that will be serialized via pack into data
        */
       template<typename T>
-      action( std::vector<permission_level> auths, name a, name n, T&& value )
-      :code_account(a), action_name(n), authorization(std::move(auths)), data(pack(std::forward<T>(value))) {}
+      action( std::vector<permission_level> auths, struct name a, struct name n, T&& value )
+      :account(a), name(n), authorization(std::move(auths)), data(pack(std::forward<T>(value))) {}
 
-      EOSLIB_SERIALIZE( action, (code_account)(action_name)(authorization)(data) )
+      EOSLIB_SERIALIZE( action, (account)(name)(authorization)(data) )
 
       /**
        * Send the action as inline action

libraries/eosiolib/contract.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <eosiolib/name.hpp>
+#include <eosiolib/datastream.hpp>
 
 namespace eosio {
 
@@ -23,9 +24,20 @@ class contract {
        * Construct a new contract given the contract name
        *
        * @brief Construct a new contract object.
-       * @param n - The name of this contract
+       * @param receiver - The name of this contract
+       * @param code - The code name of the action this contract is processing.
        */
-      contract( name n ):_self(n){}
+      contract( name receiver, name code ):_self(receiver), _code(code) {}
+
+      /**
+       * Construct a new contract given the contract name
+       *
+       * @brief Construct a new contract object.
+       * @param receiver - The name of this contract
+       * @param code - The code name of the action this contract is processing.
+       * @param ds - The datastream used 
+       */
+      contract( name receiver, name code, datastream<const char*> ds ):_self(receiver),_code(code),_ds(ds) {}
 
       /**
        *
@@ -35,6 +47,20 @@ class contract {
        * @return name - The name of this contract
        */
       inline name get_self()const { return _self; }
+
+      /**
+       * The code name of the action this contract is processing.
+       * @brief The code name of the action this contract is processing.
+       * @return name - The code name of the action this contract is processing.
+       */
+      inline name get_code()const { return _code; }
+
+      /**
+       * Get the datastream for this contract
+       * @brief Get the datastream for this contract
+       * @return datastream<const char*> - The datastream for this contract 
+       */
+      inline datastream<const char*> get_datastream()const { return _ds; }
 
    protected:
       /**
@@ -43,6 +69,19 @@ class contract {
        * @brief The name of this contract.
        */
       name _self;
+
+      /**
+       * The code name of the action this contract is processing.
+       *
+       * @brief The code name of the action this contract is processing.
+       */
+      name _code;
+
+      /**
+       * The datastream for this contract
+       *@ The datastream for this contract
+       */
+      datastream<const char*> _ds = datastream<const char*>(nullptr, 0);
 };
 
 /// @} contracttype

libraries/eosiolib/datastream.hpp

@@ -374,7 +374,7 @@ inline datastream<Stream>& operator>>(datastream<Stream>& ds, eosio::symbol& sym
  *
  *  @brief Serialize ignored_wrapper<T>'s T value 
  *  @param ds - The stream to write
- *  @param ignore - The value to serialize
+ *  @param val - The value to serialize
  *  @tparam Stream - Type of datastream buffer
  *  @return datastream<Stream>& - Reference to the datastream
  */

libraries/eosiolib/dispatcher.hpp

@@ -62,8 +62,8 @@ namespace eosio {
     * @param func - The action handler
     * @return true
     */
-   template<typename T, typename Q, typename... Args>
-   bool execute_action( T* obj, void (Q::*func)(Args...)  ) {
+   template<typename T, typename... Args>
+   bool execute_action( name self, name code, void (T::*func)(Args...)  ) {
       size_t size = action_data_size();
 
       //using malloc/free here potentially is not exception-safe, although WASM doesn't support exceptions
@@ -73,31 +73,34 @@ namespace eosio {
          buffer = max_stack_buffer_size < size ? malloc(size) : alloca(size);
          read_action_data( buffer, size );
       }
-
-      auto args = unpack<std::tuple<std::decay_t<Args>...>>( (char*)buffer, size );
-
-      if ( max_stack_buffer_size < size ) {
-         free(buffer);
-      }
+      
+      std::tuple<std::decay_t<Args>...> args;
+      datastream<const char*> ds((char*)buffer, size);
+      ds >> args;
+
+      T inst(self, code, ds);
 
       auto f2 = [&]( auto... a ){
-         (obj->*func)( a... );
+         ((&inst)->*func)( a... );
       };
 
       boost::mp11::tuple_apply( f2, args );
+      if ( max_stack_buffer_size < size ) {
+         free(buffer);
+      }
       return true;
    }
  /// @}  dispatcher
 
-// Helper macro for EOSIO_API
-#define EOSIO_API_CALL( r, OP, elem ) \
+// Helper macro for EOSIO_DISPATCH_INTERNAL
+#define EOSIO_DISPATCH_INTERNAL( r, OP, elem ) \
    case eosio::name( BOOST_PP_STRINGIZE(elem) ).value: \
-      eosio::execute_action( &thiscontract, &OP::elem ); \
+      eosio::execute_action( eosio::name(receiver), eosio::name(code), &OP::elem ); \
       break;
 
-// Helper macro for EOSIO_ABI
-#define EOSIO_API( TYPE,  MEMBERS ) \
-   BOOST_PP_SEQ_FOR_EACH( EOSIO_API_CALL, TYPE, MEMBERS )
+// Helper macro for EOSIO_DISPATCH
+#define EOSIO_DISPATCH_HELPER( TYPE,  MEMBERS ) \
+   BOOST_PP_SEQ_FOR_EACH( EOSIO_DISPATCH_INTERNAL, TYPE, MEMBERS )
 
 /**
  * @addtogroup dispatcher
@@ -114,21 +117,15 @@ namespace eosio {
  *
  * Example:
  * @code
- * EOSIO_ABI( eosio::bios, (setpriv)(setalimits)(setglimits)(setprods)(reqauth) )
+ * EOSIO_DISPATCH( eosio::bios, (setpriv)(setalimits)(setglimits)(setprods)(reqauth) )
  * @endcode
  */
-#define EOSIO_ABI( TYPE, MEMBERS ) \
+#define EOSIO_DISPATCH( TYPE, MEMBERS ) \
 extern "C" { \
    void apply( uint64_t receiver, uint64_t code, uint64_t action ) { \
-      eosio::name self(receiver); \
-      if( action == eosio::name("onerror").value) { \
-         /* onerror is only valid if it is for the "eosio" code account and authorized by "eosio"'s "active permission */ \
-         eosio_assert(code == eosio::name("eosio").value, "onerror action's are only valid from the \"eosio\" system account"); \
-      } \
-      if( code == self.value || action == eosio::name("onerror").value ) { \
-         TYPE thiscontract( self ); \
+      if( code == receiver ) { \
          switch( action ) { \
-            EOSIO_API( TYPE, MEMBERS ) \
+            EOSIO_DISPATCH_HELPER( TYPE, MEMBERS ) \
          } \
          /* does not allow destructor of thiscontract to run: eosio_exit(0); */ \
       } \

libraries/eosiolib/eosio.hpp

@@ -8,3 +8,10 @@
 #include <eosiolib/multi_index.hpp>
 #include <eosiolib/dispatcher.hpp>
 #include <eosiolib/contract.hpp>
+
+/**
+ * Helper macros to reduce the verbosity for common contracts
+ */
+#define CONTRACT class [[eosio::contract]]
+#define ACTION   [[eosio::action]] void
+#define TABLE struct [[eosio::table]]