Ejemplo n.º 1
0
        //架构性代码和协议生成
        public static void GenStructs()
        {
            sb.Clear();
            sb = GenCommon.GenHeader(sb, "DBTypes.h", vesion, "生成所有的数据表结构类,一张表对应一个类。");
            sb.Append(@"#pragma once
#include <string>
namespace DBProduce
{
");
            foreach (KeyValuePair <String, List <DBField> > table in DownDatas.tables)
            {
                sb.Append(@"	struct "+ table.Key + @"
	{"    );
                foreach (DBField field in table.Value)
                {
                    sb.Append(@"
		"         + TypesChange.dbtocpp(field.type) + @" " + field.name + @";");
                }
                sb.Append(@"
	};
");
            }
            sb.Append(@"}");
            OutPut.Out(GlobalData.SavePath + "\\DBTypes.h", sb.ToString());
        }
Ejemplo n.º 2
0
        public static void GenDBHandler()
        {
            sb.Clear();
            sb = GenCommon.GenHeader(sb, "DBHandler.h", vesion, "数据库处理接口,任何调用车可以继承这个接口实现数据库的处理方法实现。");

            sb.Append(@"#pragma once
#include <memory>
#include ""DBTypes.h""
namespace DBProduce
{
	class DBHandler
	{
		public:
			DBHandler();
			virtual ~DBHandler();"            );
            foreach (KeyValuePair <String, List <DBField> > table in DownDatas.tables)
            {
                sb.Append(@"
			virtual void read"             + table.Key + @"(std::shared_ptr <DBProduce::" + table.Key + @"> _" + table.Key + @")=0;");
            }
            sb.Append(@"
	};

}
");
            OutPut.Out(GlobalData.SavePath + "\\DBHandler.h", sb.ToString());
            //cpp文件------------------------------------------------------------
            sb.Clear();
            sb = GenCommon.GenHeader(sb, "DBHandler.cpp", vesion, "数据库处理接口,任何调用车可以继承这个接口实现数据库的处理方法实现。");
            sb.Append(@"#include ""DBHandler.h""

namespace DBProduce
{
	DBHandler::DBHandler()
	{

	}
	DBHandler::~DBHandler()
	{

	}"    );
            foreach (KeyValuePair <String, List <DBField> > table in DownDatas.tables)
            {
                sb.Append(@"
	void DBHandler::read"     + table.Key + @"(std::shared_ptr <DBProduce::" + table.Key + @"> _" + table.Key + @")
	{
		
	}
");
            }
            sb.Append(@"
}
");
            OutPut.Out(GlobalData.SavePath + "\\DBHandler.cpp", sb.ToString());
        }
Ejemplo n.º 3
0
        public static void GenIds()
        {
            sb.Clear();
            sb = GenCommon.GenHeader(sb, "DBIds.h", vesion, "用于管理对应数据表的最大id,每次插入id+1。");

            sb.Append(@"#pragma once
namespace DBProduce
{
	class DBIds
    {
    public:");
            foreach (KeyValuePair <String, List <DBField> > table in DownDatas.tables)
            {
                sb.Append(@"
        static int " + table.Key + @";");
            }
            sb.Append(@"
    };
}");
            OutPut.Out(folder + "DBIds.h", sb.ToString());
            //cpp文件------------------------------------------------------------------------------

            sb.Clear();
            sb = GenCommon.GenHeader(sb, "DBIds.cpp", vesion, "用于管理对应数据表的最大id,每次插入id+1。");

            sb.Append(@"#include ""All.h""
namespace DBProduce
{
");
            foreach (KeyValuePair <String, List <DBField> > table in DownDatas.tables)
            {
                sb.Append(@"
    int DBIds::" + table.Key + @"=0;");
            }
            sb.Append(@"
}");
            OutPut.Out(folder + "DBIds.cpp", sb.ToString());
        }
Ejemplo n.º 4
0
        //业务性代码和协议生成
        public static void GenDBGameTask()
        {
            sb.Clear();
            sb = GenCommon.GenHeader(sb, "DGameTask.h", vesion, "用于实现游戏服务器与数据服务器的数据表操作消息处理");
            sb.Append(@"#pragma once

class DGameTask: public wdcyClient
{
	private:
		
	public:
		DGameTask(wdcyTcpServerDispatcher *pDispatcher, evutil_socket_t fd)
				: wdcyClient(pDispatcher, fd)
		{
			registerMsgHandle();
		}
		
		/*
		 * @brief 客户端已经建立连接
		 */
		void onConnected();

		/*
		 * @brief 客户端断开连接
		 */
		void onDisconnected();

		/*
		 * @brief 连接验证
		 */
		int verifyConn(const MessageHead* pMsg, const uint32_t iLength);
		/*
		 * @brief 消息解析
		 */
		void msgParse(const MessageHead* pMsg, const uint32_t iLength);

		/*
		 * @brief 消息注册
		 */
		void registerMsgHandle();
	private:
		wdcyMsgRouter m_MsgRouter;
    public:
		//自定义事件"        );
            foreach (KeyValuePair <String, List <DBField> > table in DownDatas.tables)
            {
                sb.Append(@"
        //表" + table.Key + @"的增删改查操作
        int onGet" + table.Key + @"(const MessageHead* pMsg, const uint32_t iLength);
		int onCreate"         + table.Key + @"(const MessageHead* pMsg, const uint32_t iLength);
		int onUpdate"         + table.Key + @"(const MessageHead* pMsg, const uint32_t iLength);
		int onDelete"         + table.Key + @"(const MessageHead* pMsg, const uint32_t iLength);

");
            }
            sb.Append(@"
	};

");
            OutPut.Out(folder + "DGameTask.h", sb.ToString());
            //CPP文件---------------------------------------------------------------------------
            sb.Clear();
            sb = GenCommon.GenHeader(sb, "DGameTask.cpp", vesion, "用于实现游戏服务器与数据服务器的数据表操作消息处理");

            sb.Append(@"#include ""All.h""

/*
 * @brief 客户端已经建立连接
 */
void DGameTask::onConnected()
{
	std::cout << ""有游戏服务器连接进来"" << std::endl;
	DGameTaskMgr::getInstance().addClient(this);
}

/*
 * @brief 客户端断开连接
 */
void DGameTask::onDisconnected()
{
	std::cout << ""有游戏服务器断开连接"" << std::endl;
	DGameTaskMgr::getInstance().removeClient(getSockId());
}

/*
 * @brief 游戏服务器连接验证
 */
int DGameTask::verifyConn(const MessageHead* pMsg, const uint32_t iLength)
{
	std::cout << ""游戏服务器进行验证"" << std::endl;
	GD_LogicRegister stMsg;
	stMsg.ParseFromArray(pMsg->data, pMsg->length);
	
	std::cout << ""passwd:"" << stMsg.uiserverid() << std::endl;
	std::cout << ""--------------------------"" << std::endl;
	DG_LogicRegister sendMsg;
	sendMsg.set_iret(0);
	
	Net::send(this, sendMsg, DG_REGISTER);
	std::cout << ""verifyConn success"" << std::endl;
	
	return 0;
}

/*
 * @brief 消息解析
 */
void DGameTask::msgParse(const MessageHead* pMsg, const uint32_t iLength)
{
	bool bResult = m_MsgRouter.HandMsg(pMsg, pMsg->length);
	if (!bResult)
	{
		//GAME_LOG(LOG_ERROR, ""解析消息错误,:%d"", pMsg->msgId);
	}
}
");

            sb.Append(@"/*
 * @brief 消息注册
 */
void DGameTask::registerMsgHandle()
{
#define REGIST_MSG_HANDLE(msgid, func) \
	m_MsgRouter.regMsgHandler(msgid, std::bind(&DGameTask::func, this, std::placeholders::_1, std::placeholders::_2));
	"    );
            foreach (KeyValuePair <String, List <DBField> > table in DownDatas.tables)
            {
                sb.Append(@"
    //表" + table.Key + @"操作消息注册
    REGIST_MSG_HANDLE(GD_GET_" + table.Key.ToUpper() + @", onGet" + table.Key + @");
    REGIST_MSG_HANDLE(GD_CREATE_" + table.Key.ToUpper() + @", onCreate" + table.Key + @");
    REGIST_MSG_HANDLE(GD_UPDATE_" + table.Key.ToUpper() + @", onUpdate" + table.Key + @");
    REGIST_MSG_HANDLE(GD_DELETE_" + table.Key.ToUpper() + @", onDelete" + table.Key + @");

");
            }
            sb.Append(@"
}");

            foreach (KeyValuePair <String, List <DBField> > table in DownDatas.tables)
            {
                sb.Append(@"
int DGameTask::onGet" + table.Key + @"(const MessageHead* pMsg, const uint32_t iLength)
{");
                sb.Append(@"
	GD_Get"     + table.Key + @" stMsg;
	stMsg.ParseFromArray(pMsg->data, pMsg->length);
	
	std::shared_ptr < DBProduce::"     + table.Key + @" > p" + table.Key + @"(new DBProduce::" + table.Key + @"());
	if (DBProduce::RedisReader::Get"     + table.Key + @"(p" + table.Key + @", stMsg." + TypesChange.dbtoProtohead(table.Value[0].type) + table.Key + table.Value[0].name + @"()))
	{
		DG_Get"         + table.Key + @" sendMsg;
		PD::"         + table.Key + @"* st" + table.Key + @" = sendMsg.mutable_st" + table.Key + @"();
		
		sendMsg.set_iret(0);
	    sendMsg.set_uiaccid(stMsg.uiaccid());
		"        );
                for (int i = 0; i < table.Value.Count; i++)
                {
                    sb.Append(@"
		st"         + table.Key + @"->set_" + TypesChange.dbtoProtohead(table.Value[i].type) + table.Value[i].name + @"(p" + table.Key + @" ->" + table.Value[i].name + @");
");
                }
                sb.Append(@"
        
		Net::send(this, sendMsg, DG_GET_"         + table.Key.ToUpper() + @");
		GAME_LOG(LOG_INFO, ""获取"         + table.Key + @"成功"");

	}
	else
	{
		DG_Get"         + table.Key + @" sendMsg;
		PD::"         + table.Key + @"* st" + table.Key + @" = sendMsg.mutable_st" + table.Key + @"();
		sendMsg.set_iret(-1);
		sendMsg.set_uiaccid(stMsg.uiaccid());
		Net::send(this, sendMsg, DG_GET_"         + table.Key.ToUpper() + @");
		GAME_LOG(LOG_INFO,""获取"         + table.Key + @"失败"");

	}
	return 0;"    );

                sb.Append(@"
}");

                sb.Append(@"
int DGameTask::onCreate" + table.Key + @"(const MessageHead* pMsg, const uint32_t iLength)
{");

                sb.Append(@"
	GD_Create"     + table.Key + @" stMsg;
	stMsg.ParseFromArray(pMsg->data, pMsg->length);
	
	std::shared_ptr < DBProduce::"     + table.Key + @" > p" + table.Key + @"(new DBProduce::" + table.Key + @"());
	if (!DBProduce::RedisReader::Get"     + table.Key + @"(p" + table.Key + @", stMsg.st" + table.Key + @"()." + TypesChange.dbtoProtohead(table.Value[0].type) + table.Value[0].name + @"()))
	{
		std::shared_ptr < DBProduce::DBMsg > dbMsg(new DBProduce::DBMsg());
		dbMsg->id = stMsg.st"         + table.Key + @"()." + TypesChange.dbtoProtohead(table.Value[0].type) + table.Value[0].name + @"();
		dbMsg->dbCMD = DBProduce::DBCMD::dbinsert;
		dbMsg->tablename = """         + table.Key + @""";
		std::shared_ptr < std::map<std::string, std::string>
		        > data(new std::map<std::string, std::string>());
        ");
                for (int i = 1; i < table.Value.Count; i++)
                {
                    if (TypesChange.dbtocpp(table.Value[i].type) != "std::string")
                    {
                        sb.Append(@"
	data->insert(
		        std::pair<std::string, std::string>("""         + table.Value[i].name + @""",
		                std::to_string(stMsg.st"         + table.Key + @"()." + TypesChange.dbtoProtohead(table.Value[i].type) + table.Value[i].name + @"())));");
                    }
                    else
                    {
                        sb.Append(@"
	data->insert(
		        std::pair<std::string, std::string>("""         + table.Value[i].name + @""",
		                stMsg.st"         + table.Key + @"()." + TypesChange.dbtoProtohead(table.Value[i].type) + table.Value[i].name + @"()));");
                    }
                }
                sb.Append(@"
		dbMsg->data = data;
		DBProduce::WriteBackMgr::getInstance().WriteBack(dbMsg);
		
		DG_Create"         + table.Key + @" sendMsg;
		sendMsg.set_iret(0);
		sendMsg.set_uiaccid(stMsg.uiaccid());

        PD::" + table.Key + @"* st" + table.Key + @" = sendMsg.mutable_st" + table.Key + @"();
		
		"        );
                for (int i = 0; i < table.Value.Count; i++)
                {
                    sb.Append(@"
		st"         + table.Key + @"->set_" + TypesChange.dbtoProtohead(table.Value[i].type) + table.Value[i].name + @"(stMsg.st" + table.Key + @"()." + TypesChange.dbtoProtohead(table.Value[i].type) + table.Value[i].name + @"());
");
                }
                sb.Append(@"
    ");

                sb.Append(@"
		Net::send(this, sendMsg, DG_CREATE_"         + table.Key.ToUpper() + @");
		GAME_LOG(LOG_INFO, ""创建"         + table.Key + @"成功"");
	}
	else
	{
		DG_Create"         + table.Key + @" sendMsg;
		sendMsg.set_iret(-1);
		sendMsg.set_uiaccid(stMsg.uiaccid());
		Net::send(this, sendMsg, DG_CREATE_"         + table.Key.ToUpper() + @");
		GAME_LOG(LOG_INFO, ""创建_"         + table.Key + @"失败"");
	}
	
	return 0;
                ");

                sb.Append(@"
}");

                sb.Append(@"
int DGameTask::onUpdate" + table.Key + @"(const MessageHead* pMsg, const uint32_t iLength)
{");
                sb.Append(@"
GD_Update" + table.Key + @" stMsg;
	stMsg.ParseFromArray(pMsg->data, pMsg->length);
	std::shared_ptr < DBProduce::"     + table.Key + @" > p" + table.Key + @"(new DBProduce::" + table.Key + @"());
	if (DBProduce::RedisReader::Get"     + table.Key + @"(p" + table.Key + @", stMsg.st" + table.Key + @"()." + TypesChange.dbtoProtohead(table.Value[0].type) + table.Value[0].name + @"()))
	{
		std::shared_ptr < DBProduce::DBMsg > dbMsg(new DBProduce::DBMsg());
		dbMsg->id = stMsg.st"         + table.Key + @"()." + TypesChange.dbtoProtohead(table.Value[0].type) + table.Value[0].name + @"();

		dbMsg->dbCMD = DBProduce::DBCMD::dbupdate;
		dbMsg->tablename = """         + table.Key + @""";
		std::shared_ptr < std::map<std::string, std::string>
		> data(new std::map<std::string, std::string>());
");
                for (int i = 1; i < table.Value.Count; i++)
                {
                    if (TypesChange.dbtocpp(table.Value[i].type) != "std::string")
                    {
                        sb.Append(@"
	data->insert(
		        std::pair<std::string, std::string>("""         + table.Value[i].name + @""",
		                std::to_string(stMsg.st"         + table.Key + @"()." + TypesChange.dbtoProtohead(table.Value[i].type) + table.Value[i].name + @"())));");
                    }
                    else
                    {
                        sb.Append(@"
	data->insert(
		        std::pair<std::string, std::string>("""         + table.Value[i].name + @""",
		                stMsg.st"         + table.Key + @"()." + TypesChange.dbtoProtohead(table.Value[i].type) + table.Value[i].name + @"()));");
                    }
                }
                sb.Append(@"
		dbMsg->data = data;
		DBProduce::WriteBackMgr::getInstance().WriteBack(dbMsg);

		DG_Update"         + table.Key + @" sendMsg;
		sendMsg.set_iret(0);
		sendMsg.set_uiaccid(stMsg.uiaccid());
		Net::send(this, sendMsg, DG_UPDATE_"         + table.Key.ToUpper() + @");
		GAME_LOG(LOG_INFO, ""更新"         + table.Key + @"成功"");
	}
	else
	{
		DG_Update"         + table.Key + @" sendMsg;
		sendMsg.set_iret(-1);
		sendMsg.set_uiaccid(stMsg.uiaccid());
		Net::send(this, sendMsg, DG_UPDATE_"         + table.Key.ToUpper() + @");
		GAME_LOG(LOG_INFO, ""更新"         + table.Key + @"失败"");
	}
	return 0;
");

                sb.Append(@"
}");

                sb.Append(@"
int DGameTask::onDelete" + table.Key + @"(const MessageHead* pMsg, const uint32_t iLength)
{");

                sb.Append(@"
	GD_Delete"     + table.Key + @" stMsg;
	stMsg.ParseFromArray(pMsg->data, pMsg->length);

	std::shared_ptr < DBProduce::"     + table.Key + @" > p" + table.Key + @"(new DBProduce::" + table.Key + @"());
	if (DBProduce::RedisReader::Get"     + table.Key + @"(p" + table.Key + @", stMsg." + TypesChange.dbtoProtohead(table.Value[0].type) + table.Key + table.Value[0].name + @"()))
	{
		std::shared_ptr < DBProduce::DBMsg > dbMsg(new DBProduce::DBMsg());
		dbMsg->id = stMsg."         + TypesChange.dbtoProtohead(table.Value[0].type) + table.Key + table.Value[0].name + @"();
		dbMsg->dbCMD = DBProduce::DBCMD::dbdelete;
		dbMsg->tablename = """         + table.Key + @""";
		std::shared_ptr < std::map<std::string, std::string>
		> data(new std::map<std::string, std::string>());
		data->insert(
			std::pair<std::string, std::string>("""             + table.Value[0].name + @""",
			std::to_string(stMsg."             + TypesChange.dbtoProtohead(table.Value[0].type) + table.Key + table.Value[0].name + @"())));
		

		dbMsg->data = data;
		DBProduce::WriteBackMgr::getInstance().WriteBack(dbMsg);

		DG_Delete"         + table.Key + @" sendMsg;
		sendMsg.set_iret(0);
		sendMsg.set_uiaccid(stMsg.uiaccid());
		Net::send(this, sendMsg, DG_DELETE_"         + table.Key.ToUpper() + @");
		GAME_LOG(LOG_INFO, ""删除"         + table.Key + @"成功"");
	}
	else
	{
		DG_Get"         + table.Key + @"  sendMsg;
		sendMsg.set_iret(-1);
        sendMsg.set_uiaccid(stMsg.uiaccid());
		Net::send(this, sendMsg, DG_DELETE_"         + table.Key.ToUpper() + @");
		GAME_LOG(LOG_INFO, ""删除"         + table.Key + @"失败"");
	}

	return 0;
");

                sb.Append(@"
}");
            }

            OutPut.Out(folder + "DGameTask.cpp", sb.ToString());
        }
Ejemplo n.º 5
0
        public static void GenRedisReader()
        {
            sb.Clear();
            sb = GenCommon.GenHeader(sb, "RedisReader.h", vesion, "RedisReader是用作功用查询redis数据库的读取器,调用其中方法读出相应的结构。");
            sb.Append(@"#pragma once
#include ""DBTypes.h""
namespace DBProduce
{
	class RedisReader
	{
		private:
			static DBProduce::RedisDBEngine* redisEngine;
		public:
			static void setRedisEngine(DBProduce::RedisDBEngine* _redisEngine);"            );
            foreach (KeyValuePair <String, List <DBField> > table in DownDatas.tables)
            {
                sb.Append(@"
			static bool Get"             + table.Key + @"(std::shared_ptr<" + table.Key + @"> p, std::string  " + table.Value[0].name + @");");
            }
            sb.Append(@"
	};

}
");
            OutPut.Out(folder + "RedisReader.h", sb.ToString());
            //CPP文件---------------------------------------------------------------------------
            sb.Clear();
            sb = GenCommon.GenHeader(sb, "RedisReader.cpp", vesion, "RedisReader是用作功用查询redis数据库的读取器,调用其中方法读出相应的结构。");
            sb.Append(@"#include ""All.h""
namespace DBProduce
{
    DBProduce::RedisDBEngine* RedisReader::redisEngine = nullptr;
	void RedisReader::setRedisEngine(DBProduce::RedisDBEngine* _redisEngine)
	{
		redisEngine = _redisEngine;
	}"    );
            foreach (KeyValuePair <String, List <DBField> > table in DownDatas.tables)
            {
                sb.Append(@"
	bool RedisReader::Get"     + table.Key + @"(std::shared_ptr<" + table.Key + @"> p, std::string " + table.Value[0].name + @")

    {
		if (p == nullptr)
		{
			return false;
		}
		std::string results = """";
		std::string cmd = ""hmget "         + table.Key + @":"" + " + table.Value[0].name + @"
                + """);//account passwd nickname
                for (int i = 1; i < table.Value.Count; i++)
                {
                    sb.Append(@" " + table.Value[i].name + @" ");
                }

                sb.Append(@""";
		if (!redisEngine->excuteCommoned(cmd.c_str(), results))
		{
			return false;
		}
		std::vector < std::string > vec;
		DBCommon::split(results, vec, "" "");
		if (vec.size() >= "         + (table.Value.Count - 1) + @")
		{
            p->" + table.Value[0].name + @" = atof(" + table.Value[0].name + @".c_str());");
                for (int i = 1; i < table.Value.Count; i++)
                {
                    if (table.Value[i].type == "float" ||
                        table.Value[i].type == "double" ||
                        table.Value[i].type == "decimal")
                    {
                        sb.Append(@"
            p->" + table.Value[i].name + @" = atof(vec[" + (i - 1) + @"].c_str());");
                    }
                    else if (table.Value[i].type == "short" ||
                             table.Value[i].type == "int")
                    {
                        sb.Append(@"
            p->" + table.Value[i].name + @" = atoi(vec[" + (i - 1) + @"].c_str());");
                    }
                    else if (table.Value[i].type == "long")
                    {
                        sb.Append(@"
            p->" + table.Value[i].name + @" = atol(vec[" + (i - 1) + @"].c_str());");
                    }
                    else if (table.Value[i].type == "bigint")
                    {
                        sb.Append(@"
            p->" + table.Value[i].name + @" = atoll(vec[" + (i - 1) + @"].c_str());");
                    }
                    else
                    {
                        sb.Append(@"
            p->" + table.Value[i].name + @" = vec[" + (i - 1) + @"];");
                    }
                }
                sb.Append(@"
        }
		else
		{
			return false;
		}
		return true;
	}"    );
            }
            sb.Append(@"
}
");
            OutPut.Out(folder + "RedisReader.cpp", sb.ToString());
        }
Ejemplo n.º 6
0
        public static void GenRedisHandler()
        {
            sb.Clear();
            sb = GenCommon.GenHeader(sb, "RedisHandler.h", vesion, "继承自DBHandler,以redis数据入库的方式来处理数据读出的数据。");
            sb.Append(@"#pragma once
namespace DBProduce
{
	class RedisHandler: public DBHandler
	{
		private:
			DBProduce::RedisDBEngine* redisDBEngine;
		public:
			RedisHandler(DBProduce::RedisDBEngine* _redisDBEngine);
			virtual ~RedisHandler();

			//清空redis中所有的数据,慎用
			void flashAll();"            );
            foreach (KeyValuePair <String, List <DBField> > table in DownDatas.tables)
            {
                sb.Append(@"
			void read"             + table.Key + @"(std::shared_ptr <DBProduce::" + table.Key + @"> _" + table.Key + @");");
            }
            sb.Append(@"
	};

}
");
            OutPut.Out(folder + "RedisHandler.h", sb.ToString());
            //CPP文件---------------------------------------------------------------------------
            sb.Clear();
            sb = GenCommon.GenHeader(sb, "RedisHandler.cpp", vesion, "继承自DBHandler,以redis数据入库的方式来处理数据读出的数据。");

            sb.Append(@"#include ""All.h""

namespace DBProduce
{
	RedisHandler::RedisHandler(DBProduce::RedisDBEngine* _redisDBEngine)
	{
		redisDBEngine = _redisDBEngine;
	}
	RedisHandler::~RedisHandler()
	{
		
	}
	void RedisHandler::flashAll()
	{
		std::string cmd = ""flushall"";
		redisDBEngine->excuteCommoned(cmd);
	}"    );

            foreach (KeyValuePair <String, List <DBField> > table in DownDatas.tables)
            {
                sb.Append(@"
	void RedisHandler::read"     + table.Key + @"(std::shared_ptr <DBProduce::" + table.Key + @"> _" + table.Key + @")
	{"    );
                sb.Append(@"
        std::string cmd = ""hmset  " + table.Key + @":"" + std::to_string((long long)_" + table.Key + @"->" + table.Value[0].name + @"); ");
                for (int i = 1; i < table.Value.Count; i++)
                {
                    if (table.Value[i].type == "blob" || table.Value[i].type == "datetime")
                    {
                        sb.Append(@"
		if (_"         + table.Key + @"->" + table.Value[i].name + @".empty())
		{
			cmd.append( "" "             + table.Value[i].name + @"  \"""" + NetUtility::replace(_" + table.Key + @"->" + table.Value[i].name + @","" "",""$$"")+""\"" "");
		}
		else
		{
			cmd.append("" "             + table.Value[i].name + @" "" + NetUtility::replace(_" + table.Key + @"->" + table.Value[i].name + @","" "",""$$""));
		}
        ");
                    }

                    else
                    {
                        if (TypesChange.dbtocpp(table.Value[i].type) == "std::string")
                        {
                            sb.Append(@"
			cmd.append("" "             + table.Value[i].name + @" "" + NetUtility::replace(_" + table.Key + @"->" + table.Value[i].name + @","" "",""$$"")); ");
                        }
                        else
                        {
                            sb.Append(@"
			cmd.append("" "             + table.Value[i].name + @" "" + NetUtility::replace(std::to_string(_" + table.Key + @"->" + table.Value[i].name + @"),"" "",""$$"") ); ");
                        }
                    }
                }
                sb.Append(@";
		redisDBEngine->excuteCommoned(cmd);
	}"    );
            }

            sb.Append(@"
}
");
            OutPut.Out(folder + "RedisHandler.cpp", sb.ToString());
        }
Ejemplo n.º 7
0
        public static void GenDBReader()
        {
            sb.Clear();
            sb = GenCommon.GenHeader(sb, "DBReader.h", vesion, "数据库统一读取实现,读取数据库所有的数据,并调用设置的处理接口进行处理。");

            sb.Append(@"#pragma once

namespace DBProduce
{
	class DBReader
	{
		private:
			static MYSQL conn;
			static MYSQL_RES *res_ptr;
			static MYSQL_ROW sqlrow;
			static std::vector<DBHandler*> dbHandlers;
		public:
			static void connection(const char* host, const char* user,
			        const char* password, const char* database);
			static void Disconnect();
			static void DBtoHandler();
			static void SetDBHandler(DBHandler* _Handler);"            );

            foreach (KeyValuePair <String, List <DBField> > table in DownDatas.tables)
            {
                sb.Append(@"
			static void "             + table.Key + @"toHandler();");
            }
            sb.Append(@"
	};

}
");
            OutPut.Out(folder + "DBReader.h", sb.ToString());
            //cpp-------------------------------------------------------------------
            sb.Clear();
            sb = GenCommon.GenHeader(sb, "DBReader.cpp", vesion, "数据库统一读取实现,读取数据库所有的数据,并调用设置的处理接口进行处理。");

            sb.Append(@"#include ""All.h""

namespace DBProduce
{
	MYSQL DBReader::conn;
	MYSQL_RES* DBReader::res_ptr = nullptr;
	MYSQL_ROW DBReader::sqlrow;
	std::vector<DBHandler*> DBReader::dbHandlers;
	void DBReader::connection(const char* host, const char* user,
	        const char* password, const char* database)
	{
		mysql_init (&conn);
		
		if (mysql_real_connect(&conn, host, user, password, database, 0, NULL,
		        0))
		{
            mysql_query(&conn, ""SET NAMES UTF8"");
			printf(""mysql %s Connection success!\n"", host);
		}
		else
		{
			fprintf(stderr, ""Connection failed!\n"");
			if (mysql_errno(&conn))
			{
				fprintf(stderr, ""Connection error %d: %s\n"", mysql_errno(&conn),
				        mysql_error(&conn));
			}
			exit (EXIT_FAILURE);
		}
	}
	void DBReader::Disconnect()
	{
        mysql_close (&conn);
	}
	void DBReader::DBtoHandler()
	{"    );
            foreach (KeyValuePair <String, List <DBField> > table in DownDatas.tables)
            {
                sb.Append(@"
        " + table.Key + @"toHandler();");
            }
            sb.Append(@"
	}
	void DBReader::SetDBHandler(DBHandler* _Handler)
	{
		dbHandlers.push_back(_Handler);
	}"    );
            foreach (KeyValuePair <String, List <DBField> > table in DownDatas.tables)
            {
                sb.Append(@"
    void DBReader::" + table.Key + @"toHandler()
	{
		int res = mysql_query(&conn, ""SELECT * from "         + table.Key + @""");
		if (res)
		{
			fprintf(stderr, ""SELECT error: %s\n"", mysql_error(&conn));
		}
		else
		{
			res_ptr = mysql_use_result(&conn);
			if (res_ptr)
			{
				while ((sqlrow = mysql_fetch_row(res_ptr)))
				{
					mysql_field_count (&conn);
					std::shared_ptr < "                     + table.Key + @"> p (new " + table.Key + @"());");

                for (int i = 0; i < table.Value.Count; i++)
                {
                    sb.Append(@"
					p->"                     + table.Value[i].name + "= ");
                    if (table.Value[i].type == "float" || table.Value[i].type == "double" ||
                        table.Value[i].type == "decimal")
                    {
                        sb.Append("atof(sqlrow[" + i + "]);");
                    }
                    else if (table.Value[i].type == "short" ||
                             table.Value[i].type == "int")
                    {
                        sb.Append("atoi(sqlrow[" + i + "]);");
                    }
                    else if (table.Value[i].type == "long")
                    {
                        sb.Append("atol(sqlrow[" + i + "]);");
                    }
                    else if (table.Value[i].type == "bigint")
                    {
                        sb.Append("atoll(sqlrow[" + i + "]);");
                    }
                    else
                    {
                        sb.Append("sqlrow[" + i + "];");
                    }
                }
                sb.Append(@"

                    if(p->" + table.Value[0].name + @">DBIds::" + table.Key + @")
                    {
                        DBIds::" + table.Key + @"=p->" + table.Value[0].name + @";
                    }
					for (auto handler : dbHandlers)
					{
						if (handler != nullptr)
                        {     
					        handler->read"                     + table.Key + @"(p);
                        }
					}
				}
				if (mysql_errno (&conn))
				{
					fprintf(stderr, ""Retrive error: %s\n"", mysql_error(&conn));
				}
				mysql_free_result (res_ptr);
			}
		}
    }");
            }
            sb.Append(@"
}
");
            OutPut.Out(folder + "DBReader.cpp", sb.ToString());
        }
Ejemplo n.º 8
0
        public static void GenDBDatas()
        {
            sb.Clear();
            sb = GenCommon.GenHeader(sb, "RedisReader.h", vesion, "RedisReader是用作功用查询redis数据库的读取器,调用其中方法读出相应的结构。");
            sb.Append(@"#pragma once
#include <mutex>
#include <thread>
#include <unordered_map>
#include ""DBTypes.h""
#include ""Singleton.h""
namespace DBProduce
{
    class DBDatas
    {
    private:");
            foreach (KeyValuePair <String, List <DBField> > table in DownDatas.tables)
            {
                sb.Append(@"
        std::mutex m" + table.Key + @"sMutex;
        std::unordered_map < long long, std::shared_ptr < " + table.Key + @" >> m" + table.Key + @"s;
");
            }
            sb.Append(@"
    public:");
            foreach (KeyValuePair <String, List <DBField> > table in DownDatas.tables)
            {
                sb.Append(@"
        bool Get" + table.Key + @"(long long id, std::shared_ptr<" + table.Key + @">& " + table.Key + @"ptr);
		bool Add"         + table.Key + @"(long long id, std::shared_ptr<" + table.Key + @">& " + table.Key + @"ptr);
		bool Sub"         + table.Key + @"(long long);
		std::unordered_map<long long, std::shared_ptr<"         + table.Key + @">>& Get" + table.Key + @"Map();
");
            }
            sb.Append(@"
	};
}
");
            OutPut.Out(GlobalData.SavePath + "\\DBDatas.h", sb.ToString());
            //CPP文件---------------------------------------------------------------------------
            sb.Clear();
            sb = GenCommon.GenHeader(sb, "RedisReader.cpp", vesion, "RedisReader是用作功用查询redis数据库的读取器,调用其中方法读出相应的结构。");
            sb.Append(@"#include ""DBDatas.h""

namespace DBProduce
{
");
            foreach (KeyValuePair <String, List <DBField> > table in DownDatas.tables)
            {
                sb.Append(@"
	bool DBDatas::Get"     + table.Key + @"(long long id, std::shared_ptr<" + table.Key + @">& " + table.Key + @"ptr)
	{
		std::lock_guard<std::mutex> lg(m"         + table.Key + @"sMutex);
		if (m"         + table.Key + @"s.find(id) != m" + table.Key + @"s.end())
		{
			"             + table.Key + @"ptr = m" + table.Key + @"s[id];
			return true;
		}
		return false;
	}
	bool DBDatas::Add"     + table.Key + @"(long long id, std::shared_ptr<" + table.Key + @">& " + table.Key + @"ptr)
	{
		std::lock_guard<std::mutex> lg(m"         + table.Key + @"sMutex);
		if (m"         + table.Key + @"s.find(id) != m" + table.Key + @"s.end())
		{
			return false;
		}
		else
		{
			m"             + table.Key + @"s.insert(std::pair<long long, std::shared_ptr<" + table.Key + @">>(id, " + table.Key + @"ptr));
			return true;
		}
	}
	bool DBDatas::Sub"     + table.Key + @"(long long id)
	{
		std::lock_guard<std::mutex> lg(m"         + table.Key + @"sMutex);
		if (m"         + table.Key + @"s.find(id) != m" + table.Key + @"s.end())
		{
			m"             + table.Key + @"s.erase(id);
			return true;
		}
		return false;
	}
	std::unordered_map<long long, std::shared_ptr<"     + table.Key + @">>& DBDatas::Get" + table.Key + @"Map()
	{
		return m"         + table.Key + @"s;
	}
");
            }
            sb.Append(@"
}
");
            OutPut.Out(GlobalData.SavePath + "\\DBDatas.cpp", sb.ToString());
        }