qtcpconnecter.cpp

BCB下的高效开发包。包含大并发的网络库

//---------------------------------------------------------------------------
#pragma hdrstop
#include "QTcpConnecter.h"
#include "windows.h"
#include <assert.h>
#include "../QNetBase/QNetBase.h"
#include "../QStdlib/QStdlib.h"
#pragma package(smart_init)
//---------------------------------------------------------------------------
using namespace qtcp_connecter;
//---------------------------------------------------------------------------
IQTcpConnecter* __stdcall IQTcpConnecter::Create(void)
{
        return new QTcpConnecter;
}
//---------------------------------------------------------------------------
__stdcall QTcpConnecter::QTcpConnecter()
{
        m_IsPowerOn = false;
        m_TimeOut = 10000;
}
//---------------------------------------------------------------------------
__stdcall QTcpConnecter::~QTcpConnecter()
{
        this->Stop();
}
//---------------------------------------------------------------------------
void __stdcall QTcpConnecter::Release(void)
{
        assert(this);
        delete this;
}
//---------------------------------------------------------------------------
bool __stdcall QTcpConnecter::Start(void)
{
        if (this->IsPowerOn())
                return false;
        assert(m_SockMap.empty());
        m_IsPowerOn = true;
        return true;
}
//---------------------------------------------------------------------------
bool __stdcall QTcpConnecter::IsPowerOn(void)const
{
        return m_IsPowerOn;
}
//---------------------------------------------------------------------------
void __stdcall QTcpConnecter::Stop(void)
{
        this->ReleaseSockMap();
        m_IsPowerOn = false;
}   
//---------------------------------------------------------------------------
bool __stdcall QTcpConnecter::PushTask(const std::string& Addr, int Port
    , const std::string& TaskName)
{
        if (!this->IsPowerOn())
                return false;
        int Socket = _QCreateSocket();//出错时, 自然invalid
        if (_QConnect(Socket, Addr, Port, false)) {// 少见的立即成功
                S_TASK_ITEM item;
                item.TaskName = TaskName;
                item.Socket = Socket;
                m_Output.send(item);
                return true;
        }
    /*    if (::WSAGetLastError() != WSAEWOULDBLOCK) {//发生错误
                _QClose(Socket);
                S_TASK_ITEM item;
                item.TaskName = TaskName;
                item.Socket = 0;
                m_Output.send(item);
                return false;
        }
   */
        SOCK_ITEM item;
        item.TaskName = TaskName;
        item.StartTime = GetTick();

        assert(m_SockMap.find(Socket) == m_SockMap.end());//socket保证不重复
        m_SockMap[Socket] = item;
        return true;
}   
//---------------------------------------------------------------------------
bool __stdcall QTcpConnecter::ReadResult(std::string* pTaskName, int* pSocket)
{
        if (!pTaskName || !pSocket)
                return false;
        S_TASK_ITEM item;
        if (!m_Output.recv(&item))
                return false;
        *pTaskName = item.TaskName;
        *pSocket   = item.Socket;
        return true;
}
//---------------------------------------------------------------------------
void __stdcall QTcpConnecter::Process(void)
{
        if (!this->IsPowerOn())
                return;
        if (m_SockMap.empty())
                return;
        this->ProcessExcept();
        this->ProcessWrite();
        this->ProcessTimeOut();
}

//---------------------------------------------------------------------------
// Private:
//---------------------------------------------------------------------------
void QTcpConnecter::ReleaseSockMap(void)
{
        SOCK_MAP::const_iterator iter = m_SockMap.begin();
        const SOCK_MAP::const_iterator iend = m_SockMap.end();
        for(; iter != iend; ++iter) {
                _QClose(iter->first);
                S_TASK_ITEM item;
                item.TaskName = iter->second.TaskName;
                item.Socket = 0;
                m_Output.send(item);
        }
        m_SockMap.clear();
}      
//---------------------------------------------------------------------------
void QTcpConnecter::ProcessExcept(void)
{
        SOCK_MAP::iterator iter = m_SockMap.begin();
        const SOCK_MAP::iterator iend = m_SockMap.end();
        std::vector<int> SockInput;
        std::vector<int> SockOutPut;
        for(; iter != iend; ++iter) {
                SockInput.push_back(iter->first);
        }
        _QSelectExcept(SockInput, &SockOutPut);
        for(unsigned int i = 0; i < SockOutPut.size(); ++i) {
                _QClose(SockOutPut[i]);
                assert(m_SockMap.find(SockOutPut[i]) != m_SockMap.end());//socket保证存在
                S_TASK_ITEM item;
                item.TaskName = m_SockMap[SockOutPut[i]].TaskName;
                item.Socket   = 0;
                m_Output.send(item);
                m_SockMap.erase(SockOutPut[i]);
        }
}           
//---------------------------------------------------------------------------
void QTcpConnecter::ProcessWrite(void)
{
        SOCK_MAP::iterator iter = m_SockMap.begin();
        const SOCK_MAP::iterator iend = m_SockMap.end();
        std::vector<int> SockInput;
        std::vector<int> SockOutPut;
        for(; iter != iend; ++iter) {
                SockInput.push_back(iter->first);
        }
        _QSelectWrite(SockInput, &SockOutPut);
        for(unsigned int i = 0; i < SockOutPut.size(); ++i) {
                assert(m_SockMap.find(SockOutPut[i]) != m_SockMap.end());//socket保证存在
                S_TASK_ITEM item;
                item.TaskName = m_SockMap[SockOutPut[i]].TaskName;
                item.Socket   = SockOutPut[i];
                m_Output.send(item);
                m_SockMap.erase(SockOutPut[i]);
        }
}                
//---------------------------------------------------------------------------
void QTcpConnecter::ProcessTimeOut(void)
{
        SOCK_MAP::iterator iter = m_SockMap.begin();
        const SOCK_MAP::iterator iend = m_SockMap.end();
        std::vector<int> ToDel;               

        for(; iter != iend; ++iter) {
                if ((int)GetRealTickDifference(iter->second.StartTime, GetTick()) < m_TimeOut)
                        continue;
                _QClose(iter->first);
                S_TASK_ITEM item;
                item.TaskName = iter->second.TaskName;
                item.Socket   = 0;
                m_Output.send(item);
                ToDel.push_back(iter->first);
        }
        for(unsigned int i = 0; i < ToDel.size(); ++i) {
                 m_SockMap.erase(ToDel[i]);
        }

}
//---------------------------------------------------------------------------