MunProxyDatabase.hpp

Go to the documentation of this file.

#ifndef __MUN_PROXY_DATABASE_HPP__
#define __MUN_PROXY_DATABASE_HPP__

#include <map>
#include <mrs.hpp>
#include <limits.h>
#include <sqlite/SqliteAgent.hpp>
#include <sql/SQL.hpp>
#include <stream/MunStream.hpp>
#include <version/MunVersion.hpp>
#include "config/MunProxyConfigure.hpp"

class MunProxyDatabase
{
private:
    static  MunVersion                          s_MunVersion;

    static  std::map< uint64, MrsConnection >   s_ClientConnectInfo;
    
    static  std::map< MrsConnection, uint64 >   s_ClientIdInfo;
    
    static  uint32                              s_GenUidSeed;
    
    static  uint64                              s_ProxyUid;
    
    static STREAM::ProxyCheckResponse           s_ProxyCheckResponse;
    
private:
    static  uint32      GenUid() {
        uint32  startUid = s_GenUidSeed;
        uint32  uid = 0;
        
        do {
            // ID候補の取得.
            uid = s_GenUidSeed;
            s_GenUidSeed++;
            
            // 上限に達したら 1 を設定し、循環させる
            if( UINT_MAX == s_GenUidSeed ) {
                s_GenUidSeed = 1;
            }
            
            // インデックス候補がインデックス情報として未登録であれば、そのIDを返す。
            if( s_ClientConnectInfo.end() == s_ClientConnectInfo.find(uid) )    return  uid;
        } while( startUid != uid );
        
        return  0;
    }
    
public:
    static  uint64          GetProxyUid() { return s_ProxyUid; }
    
protected:
    static  MrsConnection   GetClientConnectInfo( uint64 clientUid ) {
        std::map<uint64, MrsConnection>::iterator itr = s_ClientConnectInfo.find( clientUid );
        return  ( s_ClientConnectInfo.end() == itr ) ? NULL: itr->second;
    }
    
    static  uint64  GetClientConnectInfo( MrsConnection pMunClient ) {
        std::map<MrsConnection, uint64>::iterator itr = s_ClientIdInfo.find( pMunClient );
        return  ( s_ClientIdInfo.end() == itr ) ? 0: itr->second;
    }
    
    static  void    AddClientConnectInfo( uint64 clientUid, MrsConnection& pMunClient ) {
        s_ClientConnectInfo.insert( std::pair<uint64, MrsConnection>( clientUid, pMunClient ) );
        s_ClientIdInfo.insert( std::pair<MrsConnection, uint64>( pMunClient, clientUid ) );
    }
    
    static  void    RemoveClientConnectInfo( uint64 clientUid ) {
        MrsConnection   pMunClient = GetClientConnectInfo(clientUid);
        s_ClientIdInfo.erase(pMunClient);
        s_ClientConnectInfo.erase(clientUid);
    }
    
    static  void    RemoveClientConnectInfo( MrsConnection& pMunClient ) {
        uint64 clientUid = GetClientConnectInfo(pMunClient);
        s_ClientConnectInfo.erase(clientUid);
        s_ClientIdInfo.erase(pMunClient);
    }
    
public:
    static  bool    InitDB(MunProxyConfigure& configure);
    
    static  uint64  AddMunClient(MrsConnection& pMunClient);
    
    static  MrsConnection   GetMunClient(uint64 clientUid);
    
    static  uint64  GetMunClient(MrsConnection& pMunClient);
    
    static  void    RemoveMunClient(uint64 clientUid);
    
    static  void    RemoveMunClient(MrsConnection& pMunClient);

    static  void    Recv_Proxy_Check(MrsConnection pMunClient, STREAM::ProxyCheckRequest& request);

    static  void    Recv_Proxy_CheckResultFailure(MrsConnection pMunClient, bool isIgnoreError);

    static  void    Recv_Proxy_CheckResult(MrsConnection pMunClient, std::string response);
};

#endif  /* __MUN_PROXY_DATABASE_HPP__ */