c++boos库学习-08-自己封装一个服务

#include <iostream>
using namespace std;
#include <map>
#include <string>
#include <memory>
#include <boost/signals2.hpp>
using namespace boost::signals2;
#include <functional>
#include <windows.h>
#include <mutex>

class TyService;
class TyService_Manager
{
private:
	TyService_Manager() = default;
public:
	static auto GetInstance()
	{
		TyService_Manager s;
		return &s;
	}

	void RegisterService(string strService,std::shared_ptr<TyService> spService)
	{
		m_mapServices[strService] = spService;
	}

	auto GetService(string strServicename)->std::shared_ptr<TyService>
	{
		auto it = m_mapServices.find(strServicename);
		if (it != m_mapServices.end())
		{
			return it->second;
		}
		else
		{
			return nullptr;
		}
	}

private:
	static map<string, std::shared_ptr<TyService> > m_mapServices;
};

map<string, std::shared_ptr<TyService> > TyService_Manager::m_mapServices;

using MySingal = signal<void()>;

#define InitClassName(strName)\
public:\
string GetServiceName() override { return strName;} \
static string GetServiceName_S(){return strName;}

//服务基类，后来者可以继承这个类实现自己的一些操作
class TyService :public enable_shared_from_this<TyService>
{
public:
	void RegisterService()
	{
		auto pInstance = TyService_Manager::GetInstance();
		string name = GetServiceName();
		pInstance->RegisterService(name, GetThis());
		
	}

public:

	virtual string GetServiceName() = 0;
	virtual bool InitService() = 0;
	virtual ~TyService(){}


	std::shared_ptr<TyService> GetThis()
	{
		return shared_from_this();
	}
protected:
	std::once_flag ms_onceflag;
public:
	std::map<int, MySingal> m_mapSingals;
};




//示例
class PSBatch :public TyService
{
	InitClassName("PSBatch");
public:
	enum MyEnum
	{
		eidClick,
		eidDbClick,
	};
	
	~PSBatch()
	{

	}
public:
	
	bool InitService() override
	{
		cout << "我已经初始化了!\n";
		return true;
	}
public:
	void TestMsg(int nSig)
	{
		m_mapSingals[nSig]();
	}
};


void connect_message(std::shared_ptr<TyService> spService, int nsignal, std::function<void()> fun)
{
	spService->m_mapSingals[nsignal].connect(fun); \
}

template<typename T>
void ConnectService(std::shared_ptr<T>& sp)
{
	string strname = sp->GetServiceName_S();
	auto pInstance = TyService_Manager::GetInstance();
	std::shared_ptr<TyService> p = pInstance->GetService(strname);
	sp = std::dynamic_pointer_cast<T>(p);
}

void Register_Service(std::shared_ptr<TyService> spService)
{
	spService->RegisterService();
}

//消息映射
#define CONNECT_MESSAGE(spService,nSig,fun)\
connect_message(spService,nSig,fun);

//连接服务
#define CONNECT_SERVICE(spService)\
ConnectService(spService);

//登记服务，只有登记后才可连接服务
#define REGISTER_SERVICE(spService)\
Register_Service(spService);

class test1
{
public:
	test1()
	{
		sp = std::make_shared<PSBatch>();
		REGISTER_SERVICE(sp);
		CONNECT_MESSAGE(sp, sp->eidClick, std::bind(&test1::OnMsg,this));
	}

	void OnMsg()
	{
		cout << "test1::OnMsg()\n";
	}

	//模拟一次点击事件
	void OnClick()
	{
		cout << "点击事件触发\n";
		sp->TestMsg(sp->eidClick);
	}
private:
	shared_ptr<PSBatch> sp;
};

class test2
{
public:
	test2()
	{
		CONNECT_SERVICE(sp2);
		CONNECT_MESSAGE(sp2, sp2->eidClick, std::bind(&test2::OnMsg, this));
	}

	void OnMsg()
	{
		cout << "test2::OnMsg()\n";
	}
private:
	shared_ptr<PSBatch> sp2;
};

int main()
{	
	test1 t1;
	test2 t2;
	Sleep(2000);
	t1.OnClick();

	system("pause");
	return 0;
}

执行结果: