Peerplays_Blockchain/peerplays-fc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Remove unused bstate

Browse source
This commit is contained in:
Peter Conrad 2019-04-04 14:14:40 +02:00 committed by Peter Conrad
parent 183a81ba94
commit d5b817817a
3 changed files with 0 additions and 127 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
CMakeLists.txt
View file

@ -240,7 +240,6 @@ set( fc_sources
src/rpc/http_api.cpp
src/rpc/json_connection.cpp
src/rpc/state.cpp
src/rpc/bstate.cpp
src/rpc/websocket_api.cpp
src/log/log_message.cpp
src/log/logger.cpp

58
include/fc/rpc/bstate.hpp
View file

@ -1,58 +0,0 @@
#pragma once
#include <fc/variant.hpp>
#include <functional>
#include <fc/thread/future.hpp>
#include <fc/rpc/state.hpp>
namespace fc { namespace rpc {
typedef std::vector<char> params_type;
typedef std::vector<char> result_type;
struct brequest
{
optional<uint64_t> id;
std::string method;
params_type params;
};
struct bresponse
{
bresponse(){}
bresponse( int64_t i, result_type r ):id(i),result(r){}
bresponse( int64_t i, error_object r ):id(i),error(r){}
int64_t id = 0;
optional<result_type> result;
optional<error_object> error;
};
/** binary RPC state */
class bstate
{
public:
typedef std::function<result_type(const params_type&)> method;
~bstate();
void add_method( const std::string& name, method m );
void remove_method( const std::string& name );
result_type local_call( const string& method_name, const params_type& args );
void handle_reply( const bresponse& response );
brequest start_remote_call( const string& method_name, params_type args );
result_type wait_for_response( uint64_t request_id );
void close();
void on_unhandled( const std::function<result_type(const string&,const params_type&)>& unhandled );
private:
uint64_t _next_id = 1;
std::unordered_map<uint64_t, fc::promise<result_type>::ptr> _awaiting;
std::unordered_map<std::string, method> _methods;
std::function<result_type(const string&,const params_type&)> _unhandled;
};
} } // namespace fc::rpc
FC_REFLECT( fc::rpc::brequest, (id)(method)(params) );
FC_REFLECT( fc::rpc::bresponse, (id)(result)(error) )

68
src/rpc/bstate.cpp
View file

@ -1,68 +0,0 @@
#include <fc/rpc/bstate.hpp>
#include <fc/thread/thread.hpp>
#include <fc/reflect/variant.hpp>
namespace fc { namespace rpc {
bstate::~bstate()
{
close();
}
void bstate::add_method( const std::string& name, method m )
{
_methods.emplace(std::pair<std::string,method>(name,std::move(m)));
}
void bstate::remove_method( const std::string& name )
{
_methods.erase(name);
}
result_type bstate::local_call( const string& method_name, const params_type& args )
{
auto method_itr = _methods.find(method_name);
if( method_itr == _methods.end() && _unhandled )
return _unhandled( method_name, args );
FC_ASSERT( method_itr != _methods.end(), "Unknown Method: ${name}", ("name",method_name) );
return method_itr->second(args);
}
void bstate::handle_reply( const bresponse& bresponse )
{
auto await = _awaiting.find( bresponse.id );
FC_ASSERT( await != _awaiting.end(), "Unknown Response ID: ${id}", ("id",bresponse.id)("bresponse",bresponse) );
if( bresponse.result )
await->second->set_value( *bresponse.result );
else if( bresponse.error )
{
await->second->set_exception( exception_ptr(new FC_EXCEPTION( exception, "${error}", ("error",bresponse.error->message)("data",bresponse) ) ) );
}
else
await->second->set_value( params_type() );
_awaiting.erase(await);
}
brequest bstate::start_remote_call( const string& method_name, params_type args )
{
brequest brequest{ _next_id++, method_name, std::move(args) };
_awaiting[*brequest.id] = fc::promise<result_type>::ptr( new fc::promise<result_type>("json_connection::async_call") );
return brequest;
}
result_type bstate::wait_for_response( uint64_t request_id )
{
auto itr = _awaiting.find(request_id);
FC_ASSERT( itr != _awaiting.end() );
return fc::future<result_type>( itr->second ).wait();
}
void bstate::close()
{
for( auto item : _awaiting )
item.second->set_exception( fc::exception_ptr(new FC_EXCEPTION( eof_exception, "connection closed" )) );
_awaiting.clear();
}
void bstate::on_unhandled( const std::function<result_type(const string&, const params_type&)>& unhandled )
{
_unhandled = unhandled;
}
} } // namespace fc::rpc