BlockManager::BlockManagerWorkerActor::BlockManagerWorkerActor(Theron::Framework *framework,const char * name,BlockManager* bm)
:Actor(*framework,name),bm_(bm){
RegisterHandler(this,&BlockManagerWorkerActor::getBlock);
RegisterHandler(this,&BlockManagerWorkerActor::putBlock);
RegisterHandler(this,&BlockManagerWorkerActor::BindingPartition);
RegisterHandler(this, &BlockManagerWorkerActor::UnbindingPartition);
}
IteratorExecutorSlave::ExecuteIteratorActor::ExecuteIteratorActor(IteratorExecutorSlave* ies, Theron::Framework &framework, const char *const slaveID)
:Theron::Actor(framework, slaveID),ies(ies)
{
RegisterHandler(this, &IteratorExecutorSlave::ExecuteIteratorActor::Handler256);
RegisterHandler(this, &IteratorExecutorSlave::ExecuteIteratorActor::Handler4K);
RegisterHandler(this, &IteratorExecutorSlave::ExecuteIteratorActor::progation);
}
int CRoleDBHandlerSet::RegisterAllHandlers()
{
int iRes = 0;
iRes = RegisterHandler(MSGID_WORLD_FETCHROLE_REQUEST, &m_FetchRoleHandler);
if (iRes != 0)
{
return -1;
}
m_FetchRoleHandler.SetThreadIdx(m_iThreadIdx);
iRes = RegisterHandler(MSGID_WORLD_UPDATEROLE_REQUEST, &m_UpdateRoleHandler);
if (iRes != 0)
{
return -2;
}
m_UpdateRoleHandler.SetThreadIdx(m_iThreadIdx);
iRes = RegisterHandler(MSGID_WORLD_CREATEROLE_REQUEST, &m_CreateRoleHandler);
if (iRes != 0)
{
return -3;
}
m_CreateRoleHandler.SetThreadIdx(m_iThreadIdx);
iRes = RegisterHandler(MSGID_ACCOUNT_LISTROLE_REQUEST, &m_ListRoleHandler);
if (iRes != 0)
{
return -4;
}
m_ListRoleHandler.SetThreadIdx(m_iThreadIdx);
return 0;
}
inline MainManagerActor()
{
RegisterHandler(this, &MainManagerActor::StockMessageHandler);
RegisterHandler(this, &MainManagerActor::StockListMessageHandler);
RegisterHandler(this, &MainManagerActor::PriceResMessageHandler);
RegisterHandler(this, &MainManagerActor::PriceReqMessageHandler);
RegisterHandler(this, &MainManagerActor::MapHandler);
}
BlockManagerMaster::BlockManagerMasterActor::BlockManagerMasterActor(Theron::Framework* framework,const char *name)
:Actor(*(framework),name){
RegisterHandler(this,&BlockManagerMasterActor::workerRegister);
RegisterHandler(this,&BlockManagerMasterActor::heartbeatReceiver);
RegisterHandler(this,&BlockManagerMasterActor::blockStatusReceiver);
RegisterHandler(this,&BlockManagerMasterActor::matcherReceiver);
// cout<<"the workerRegister is ready"<<endl;
}
bool FrameworkManager::Initialise()
{
// Register handler class supporting multiple message types
auto dmh = std::make_shared<DomainManagementHandlers>(shared_from_this());
RegisterHandler(Exchange::RemoteSubscription::descriptor(), dmh);
RegisterHandler(Exchange::Wrapper::descriptor(), dmh);
return true;
}
AbstractHttpServer::AbstractHttpServer() :registry_(
new RequestHandlerRegistry()) {
// 'handler_manifest_handler' is registered in default
RegisterHandler(
"/manifest",
boost::bind(&AbstractHttpServer::GetHandlerManifest, this, _1));
}
bool FrameworkManagerY::Initialise()
{
// Register handler class for single message type
auto sph = std::make_shared<StringParameterHandler>(shared_from_this());
RegisterHandler(Exchange::StringParameter::descriptor(), sph);
return true;
}
bool InitHandler() {
RegisterHandler();
if (!InitDatabase()) {
return false;
}
return true;
}
Printer(Theron::Framework &framework) : Theron::Actor(framework)
{
// Register the handler for string messages.
RegisterHandler(this, &Printer::Print);
// Register the default handler for all other kinds of messages.
// If we don't register our own default handler then the 'default' default
// handler will be used, which asserts on receiving an unhandled message.
SetDefaultHandler(this, &Printer::DefaultHandler);
}
bool RegisterHandler(std::string Name,
std::array<std::string, sizeof...(Ts)> Attributes,
std::function<void (Ts...)> Callback)
{
return RegisterHandler(std::move(Name),
seec::makeUnique<EventHandler<Ts...>>
(*Trace,
std::move(Attributes),
std::move(Callback)));
}
inline void HandlerTwo(const Message &message, const xlang2::Address from)
{
printf("Handler TWO received message with value '%d'\n", message.mValue);
// Switch to handler one
DeregisterHandler(this, &ExampleActor::HandlerTwo);
RegisterHandler(this, &ExampleActor::HandlerOne);
Send(message, from);
}
inline void Start(const StartMessage &message, const Theron::Address /*from*/)
{
mCaller = message.mCaller;
mConsumer = message.mConsumer;
mEventQ = message.mEventQ;
std::cout << "Producer Start" << std::endl;
DeregisterHandler(this, &Producer::Start);
RegisterHandler(this, &Producer::Receive);
}
int CNameDBHandlerSet::RegisterAllHandlers()
{
int iRes = 0;
iRes = RegisterHandler(MSGID_ADDNEWNAME_REQUEST, &m_stAddNameHandler);
if (iRes != 0)
{
return -1;
}
m_stAddNameHandler.SetThreadIdx(m_iThreadIdx);
iRes = RegisterHandler(MSGID_DELETENAME_REQUEST, &m_stDeleteNameHandler);
if (iRes != 0)
{
return -2;
}
m_stDeleteNameHandler.SetThreadIdx(m_iThreadIdx);
return 0;
}
bool DbgGdb::WriteCommand( const wxString &command, DbgCmdHandler *handler )
{
wxString cmd;
wxString id = MakeId( );
cmd << id << command;
if ( !ExecuteCmd( cmd ) ) {
return false;
}
RegisterHandler( id, handler );
return true;
}
void TEMPLATE_SERVER_CLASS::Start() {
if (Initialize()) {
return;
}
RegisterHandler();
//process thread
task_queue_thread_.start();
conn_manager_from_client_.start();
/*
conn_manager_to_srv_=new ConnectionManagerToServer(
&to_server_transport_,&packet_streamer_,this);
if (!conn_manager_to_srv_->start()) {
TBSYS_LOG(ERROR,"%s","conn_manager_to_srv start error");
Stop();
return;
}*/
//transport
char spec[32];
bool ret=true;
if (ret) {
int port=TBSYS_CONFIG.getInt("server","port",10010);
sprintf(spec,"tcp::%d",port);
if (from_client_transport_.listen(spec, &packet_streamer_,this)==NULL) {
TBSYS_LOG(ERROR,"listen port %d error",port);
ret=false;
} else {
TBSYS_LOG(INFO,"listen tcp port: %d",port);
}
}
if (ret) {
TBSYS_LOG(INFO,"--- program stated PID: %d ---",getpid());
from_client_transport_.start();
to_server_transport_.start();
} else {
Stop();
}
task_queue_thread_.wait();
conn_manager_from_client_.wait();
// conn_manager_to_srv_->wait();
from_client_transport_.wait();
to_server_transport_.wait();
Destroy();
}
inline void WaitForAck(const int &message, const Theron::Address /*from EQ*/){
if (message < 0){
std::cout<<"Producer received ACK: "<<message<<std::endl;
Send(message, mCaller);
// Start Receiving message to produce
DeregisterHandler(this, &Producer::WaitForAck);
RegisterHandler(this, &Producer::Receive);
}
else
{
std::cout<<"Failed ACK signal | Ensure ACK is proper: "<<message<<std::endl;
Send(message, mCaller);
}
}
inline void Receive(const int &message, const Theron::Address /*from*/)
{
if (message > 0)
{
std::cout<<"Producer will start producing -> "<<message<<std::endl;
Send(message, mEventQ);
// Wait for Acknowledge
DeregisterHandler(this, &Producer::Receive);
RegisterHandler(this, &Producer::WaitForAck);
}
else
{
std::cout<<"Failed producing message | Ensure message is proper: "<<message<<std::endl;
Send(message, mCaller);
}
}
bool DbgGdb::WriteCommand(const wxString& command, DbgCmdHandler* handler)
{
wxString cmd;
wxString id = MakeId();
cmd << id << command;
// Support for reverse debugging
if(IsReverseDebuggingEnabled() && m_reversableCommands.count(command)) {
cmd << " --reverse";
}
if(!ExecuteCmd(cmd)) {
CL_WARNING("Failed to send command: %s", cmd);
return false;
}
RegisterHandler(id, handler);
return true;
}
STDAPI DllRegisterServer()
{
HRESULT hr = DllUnregisterServer();
assert(SUCCEEDED(hr));
std::wstring filename_;
hr = ComReg::ComRegGetModuleFileName(g_hModule, filename_);
assert(SUCCEEDED(hr));
assert(!filename_.empty());
const wchar_t* const filename = filename_.c_str();
//RegisterSource(filename);
RegisterHandler(filename);
return S_OK;
}
CSGOClient::CSGOClient()
:m_availableCb(this, &CSGOClient::OnMessageAvailable)
, m_failedCb(this, &CSGOClient::OnMessageFailed)
, m_welcomeHandler(this, &CSGOClient::OnClientWelcome)
{
m_gameCoordinator = (ISteamGameCoordinator*)SteamClient()
->GetISteamGenericInterface(GetHSteamUser(),
GetHSteamPipe(),
STEAMGAMECOORDINATOR_INTERFACE_VERSION);
RegisterHandler(k_EMsgGCClientWelcome, &m_welcomeHandler);
CMsgClientHello hello;
hello.set_client_session_need(1);
if (SendGCMessage(k_EMsgGCClientHello, &hello) != k_EGCResultOK)
throw BoilerException("failed to send GCClientHello");
}
inline SimpleActor()
{
// Register message handler functions.
RegisterHandler(this, &SimpleActor::FloatHandler);
RegisterHandler(this, &SimpleActor::IntegerHandler);
}
inline ClassifyActor()
{
RegisterHandler(this, &ClassifyActor::FetchResultHandler);
}
ResourceManagerMaster::ResourceManagerMasterActor::ResourceManagerMasterActor(Theron::Framework* framework,ResourceManagerMaster* rmm)
:Theron::Actor(*framework,"ResourceManagerMaster"),rmm_(rmm){
RegisterHandler(this,&ResourceManagerMasterActor::ReceiveStorageBudgetReport);
RegisterHandler(this,&ResourceManagerMasterActor::ReceiveNewNodeRegister);
}
PacketHandler::PacketHandler(void)
{
m_pFuncMap_AG = new FunctionMap;
RegisterHandler();
}
inline Producer(Theron::Framework &framework) : Theron::Actor(framework)
{
RegisterHandler(this, &Producer::Start);
}
Server::Server(threading::Executor *executor)
: port_(0), executor_(executor) {
RegisterHandler("/", std::bind(&Server::HandleListing, this, std::placeholders::_1));
SetFallbackHandler(std::bind(&Server::Handle404, this, std::placeholders::_1));
}
inline QueryActor()
{
RegisterHandler(this, &QueryActor::QueryHandler);
RegisterHandler(this, &QueryActor::MapHandler);
}
Printer1(int no,Theron::Framework &framework, const char *const name) :
Theron::Actor(framework, name),no(no)
{
RegisterHandler(this, &Printer1::Handler);
}
// Constructor.
inline FileReader()
{
RegisterHandler(this, &FileReader::Handler);
}
