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); }