usermgr.h

#ifndef __GAME_USER_MGR_H__
#define  __GAME_USER_MGR_H__
/*
   统一的gameuser 管理入口，线程安全
   */
#include "user.h"
#include "base/lock_common.h"
#include "nskernel/connection.h"
#include "async_log.h"

struct GameUserInfo
{
	int userid;  //用户的唯一ID
	GameUser* pGameuser;
	Connection* pCon; //当前的连接
	int fd;

	time_t timestamp;  //建立的时间戳，用于超时检测
	bool  bVerify;//玩家对象是否有效
	std::string session;
	int lineNum;   //分线号
	int curCjId;   //当前场景ID
	int m_nIndex;//-1：玩家对象未使用，[0,m_nMaxUserNum-1]：玩家对象正在使用。该值为自己在玩家对象池的位置，用于回收该玩家对象。
	GameUserInfo()
	{
		userid = -1;
		pCon = NULL;
		timestamp = time(NULL);
		pGameuser = NULL;
		bVerify = false;
		lineNum = -1;
		curCjId = -1;
		m_nIndex = -1;
		fd = -1;
	}

	GameUserInfo& copy(const GameUserInfo& in)
	{
		if (&in == this)
		{
			return *this;
		}
		userid = in.userid;
		pCon = in.pCon;
		timestamp = in.timestamp;
		bVerify = in.bVerify;
		lineNum = in.lineNum;
		curCjId = in.curCjId;
		fd = in.fd;
		return *this;
	}
};

typedef std::map<int,GameUserInfo*> Uid2InfoMap;
typedef  Uid2InfoMap GameUserMap ;

class UserData
{
	public :
		GameUserInfo* getUnUsedUser() //throw (std::string&)
		{
			DORW_WRLOCK(m_lockInfo);
			if (m_lstUnUsedIndex.size() == 0)
			{
			    DORW_UNLOCK(m_lockInfo);
				return NULL;
			}
			int nIndex = m_lstUnUsedIndex.front();
			m_lstUnUsedIndex.pop_front();
			(*(m_pUserContainer+nIndex))->m_nIndex = nIndex;
			DORW_UNLOCK(m_lockInfo);
			return *(m_pUserContainer+nIndex); 
		}

		void setUserUsed(int index)//throw (std::string& )
		{
			assert(index < m_nMaxUserNum);
			if (index >= m_nMaxUserNum)
			{
				return ;
			}
			DORW_WRLOCK(m_lockInfo);
			(*(m_pUserContainer+index))->m_nIndex = index;
			DORW_UNLOCK(m_lockInfo);
		}

		void setUserUnUsed(int index)//throw (std::string& )
		{
			assert(index < m_nMaxUserNum);
			if (index >= m_nMaxUserNum)
			{
				return ;
			}
			DORW_WRLOCK(m_lockInfo);
			(*(m_pUserContainer+index))->m_nIndex = -1;
			m_lstUnUsedIndex.push_back(index);
			DORW_UNLOCK(m_lockInfo);

		}
		UserData()
		{
			DORW_LOCK_INIT(m_lockInfo);
		}

	public :

		GameUserInfo** m_pUserContainer;   //user info
		std::list<int>	m_lstUnUsedIndex;	//unuser index


		RWLOCK m_lockInfo;
	public :
		int m_nMaxUserNum;	 //max user info	
};


class SProxy;

class UserMgr
{
	public:
		UserMgr();
		~UserMgr();

		GameUserInfo* newGameUser(int iUID);
		void delGameUser(GameUserInfo* del_user);
		GameUserInfo* linkGameUser(GameUserInfo* pTmp);
		void init(SProxy* proxy,int max);
		void deleteGameUser_NoLock(int iUID, bool real_del);
		//判断game user 是否存在
		bool isGameUserExist(int iUID);
		//根据uid判断用户是否在线
		bool isOnlineByUid(int iUID);

		GameUserInfo* getUserInfo(int iUID);    
		GameUserInfo* getUserInfoByUid(int uid);
		Connection*   getValidConn(void);

		void delUserInfoByUid(int uid);

		int size(){return m_mapUid2Info.size();};
		Uid2InfoMap getUidMap(){return m_mapUid2Info;};

	private:
		LOCK m_lockGameuser;
		Uid2InfoMap m_mapUid2Info;

        AsyncSysLogger *m_pLogger;
		//base::Logger* m_pLogger;
		SProxy* m_pProxy;
	private:
		//玩家对象池
		UserData m_userData;
};


#endif