zinx框架的一个简单的回显实现

一、zinx描述

        zinx框架是一个处理多路IO的框架。在这个框架中提供了若干抽象类，分别在 IO处理的多个阶段生效。开发者可以重写抽象类中的虚函数完成自己需求的处理功能。

二、zinx框架的使用步骤

        1. ZinxKernel::ZinxKernelInit() 初始化框架

        2. 写类继承AZinxHandler，重写虚函数，在函数中对参数进行处理 （比如将参数内容打印到标准输出）

        3. 写类继承Ichannel，重写虚函数完成数据收发，重写 GetInputNextStage 函数，返回第二步创建类的对象

        4. 添加步骤3类创建的对象到框架中

        5. 运行框架

三、标准输入回显标准输出的编写思路

        1. 创建三个类：标准输入类，回显类，标准输出类

        2. 重写标准输入类的读取函数

        3. 重写回显类处理函数

        4. 重写标准输出类的写出函数

        5. 创建以上三个类的全局对象（堆对象），添加通道对象到框架（kernel）

        6. 运行框架

四、添加命令处理类

        1. 创建命令处理类继承AzinxHandler，重写处理函数和获取下一个处理环节的函数

        2. 处理函数内，根据输入内容不同，要么添加输出通道，要么摘除输出通道

        3. 获取下一个处理环节函数中，指定下一个环节是退出或回显

        4. 设定输入通道的下一个环节是该类对象

五、添加日期前缀

        1. 创建添加日期类，继承AzinxHandler。重写处理函数和获取下一环 节函数

        2. 处理函数：将日期和输入字符串拼接后，new一个对象返回

        3. 获取下一环节函数：返回回显对象

        4. 在命令处理类的处理函数中：根据输入命令设置当前是否要添加前缀的状态位

        5. 在命令处理类的获取下一环节函数中，判断当前状态，需要添加前缀--》返回添加日期前缀的对象；不需要添加前缀--》返回回显对象

六、需要调用的框架静态函数

        1.初始化，去初始化 ZinxKernel::ZinxKernelInit() 和 ZinxKernel::ZinxKernelFini()

         2.运行框架 ZinxKernel::Zinx_Run()

        3.通道添加和摘除 ZinxKernel::Zinx_Add_Channel() 和 ZinxKernel::Zinx_Del_Channel()

        4.退出框架 ZinxKernel::Zinx_Exit()

七、多个AzinxHandler对象之间的信息传递

        数据封装成IzinxMsg类在多个AzinxHandler对象之间传递 使用时，要现将IZinxMsg类型引用动态转换成所需类型引用

八、zinx框架处理数据的本质

        将数据在多个AzinxHandler对象之间传递，挨个处理 传递的规则通过重写GetNextHandler函数定义

九、代码实现

#include <zinx.h>
#include <iostream>

using namespace std;
/*读标准输入，回显到标准输出*/

/*创建标准输出通道类*/
class TestStdout :public Ichannel {
	// 通过 Ichannel 继承
	virtual bool Init() override 
	{
		return true;
	}
	virtual bool ReadFd(std::string& _input) override
	{
		return false;
	}
	virtual bool WriteFd(std::string& _output) override
	{
		cout << _output << endl;
		return true;
	}
	virtual void Fini() override
	{
	}
	virtual int GetFd() override
	{
		return 1;
	}
	virtual std::string GetChannelInfo() override
	{
		return "stdout";
	}
	virtual AZinxHandler* GetInputNextStage(BytesMsg& _oInput) override
	{
		return nullptr;
	}
} *poOut = new TestStdout();


/*2-写功能处理类*/
class Echo :public AZinxHandler {

	virtual IZinxMsg* InternelHandle(IZinxMsg& _oInput) override
	{
		/*回显到标准输出*/
		GET_REF2DATA(BytesMsg, input, _oInput);
		Ichannel* poSendOut = ZinxKernel::Zinx_GetChannel_ByInfo("stdout");
		if (NULL != poSendOut)
		{
			ZinxKernel::Zinx_SendOut(input.szData, *poSendOut);
		}

		return nullptr;
	}
	virtual AZinxHandler* GetNextHandler(IZinxMsg& _oNextMsg) override
	{
		return nullptr;
	}
} *poEcho = new Echo();

class ExitFramework :public AZinxHandler {
	// 通过 AZinxHandler 继承
	virtual IZinxMsg* InternelHandle(IZinxMsg& _oInput) override
	{
		GET_REF2DATA(BytesMsg, obyte, _oInput);

		if (obyte.szData == "exit")
		{
			ZinxKernel::Zinx_Exit();
			return NULL;
		}
		/*创建交给下一个环节处理的数据*/
		return new BytesMsg(obyte);
	}
	virtual AZinxHandler* GetNextHandler(IZinxMsg& _oNextMsg) override
	{
		return poEcho;
	}
} *poExit = new ExitFramework();

class AddDate :public AZinxHandler {
	// 通过 AZinxHandler 继承
	virtual IZinxMsg* InternelHandle(IZinxMsg& _oInput) override
	{
		GET_REF2DATA(BytesMsg, oBytes, _oInput);
		time_t tmp;
		time(&tmp);
		string szNew = string(ctime(&tmp)) + oBytes.szData;
		BytesMsg* pret = new BytesMsg(oBytes);
		pret->szData = szNew;
		return pret;
	}
	virtual AZinxHandler* GetNextHandler(IZinxMsg& _oNextMsg) override
	{
		return poEcho;
	}
} *poAddDate = new AddDate();
class CmdHandler :public AZinxHandler {
	int status = 0;
	// 通过 AZinxHandler 继承
	virtual IZinxMsg* InternelHandle(IZinxMsg& _oInput) override
	{
		/*判断输入是否是open或close，执行不同操作*/
		GET_REF2DATA(BytesMsg, oBytes, _oInput);

		if (oBytes.szData == "open")
		{
			ZinxKernel::Zinx_Add_Channel(*poOut);
			return NULL;
		}
		else if (oBytes.szData == "close")
		{
			ZinxKernel::Zinx_Del_Channel(*poOut);
			return nullptr;
		}
		else if (oBytes.szData == "date")
		{
			status = 1;
			return nullptr;
		}
		else if (oBytes.szData == "cleardate")
		{
			status = 0;
		}

		return new BytesMsg(oBytes);
	}

	/*根据消息不同，选择不同的处理者*/
	virtual AZinxHandler* GetNextHandler(IZinxMsg& _oNextMsg) override
	{
		GET_REF2DATA(BytesMsg, oBytes, _oNextMsg);
		if (oBytes.szData == "exit")
		{
			return poExit;
		}
		else
		{
			if (0 == status)
			{
				return poEcho;
			}
			else
			{
				return poAddDate;
			}
		}
	}
} *poCmd = new CmdHandler();



/*3-写通道类*/
class TestStdin :public Ichannel {
	// 通过 Ichannel 继承
	virtual bool Init() override
	{
		return true;
	}
	virtual bool ReadFd(std::string& _input) override
	{
		cin >> _input;
		return true;
	}
	virtual bool WriteFd(std::string& _output) override
	{
		return false;
	}
	virtual void Fini() override
	{
	}
	virtual int GetFd() override
	{
		return 0;
	}
	virtual std::string GetChannelInfo() override
	{
		return "stdin";
	}
	virtual AZinxHandler* GetInputNextStage(BytesMsg& _oInput) override
	{
		return poCmd;
	}
};

int main()
{
	/*1-初始化框架*/
	ZinxKernel::ZinxKernelInit();

	/*4-将通道对象添加到框架*/
	TestStdin* poStdin = new TestStdin();
	ZinxKernel::Zinx_Add_Channel(*poStdin);
	ZinxKernel::Zinx_Add_Channel(*poOut);

	/*5-运行框架*/
	ZinxKernel::Zinx_Run();

	ZinxKernel::ZinxKernelFini();
	return 0;
}