qsystem.cpp

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

#include "QSystem.h"
#include "../QStdlib/QStdlib.h"
#include "Windows.h"
#include <assert.h>
//------------------------------------------------------------------------------
bool QRun(const std::string& Cmd)
{
        return WinExec(Cmd.c_str(), 1) > 31;
}
//---------------------------------------------------------------------------
int QCreateProcess(const std::string& Cmd, const std::string& Path)
{
        char Cmd_t[65536];
        strcpy(Cmd_t, Cmd.c_str());//鬼知道为什么CreateProcess这里对应参数不是const
        const char* MyPath = Path.empty() ? NULL : Path.c_str() ;
        STARTUPINFO si = {sizeof(si)};
        PROCESS_INFORMATION pi;
        si.dwFlags = STARTF_USESHOWWINDOW;
        si.wShowWindow = TRUE;
        int ret = ::CreateProcess (NULL,"notepad.exe",NULL,NULL,FALSE,FALSE,NULL,MyPath,&si,&pi);
        if (ret) {
                ::CloseHandle (pi.hThread);
                ::CloseHandle (pi.hProcess);
                return pi.dwProcessId;
        }
        return 0;
}
//---------------------------------------------------------------------------
int GetProcessHandleCount(int ProcessId)
{
        typedef long (__stdcall *NTQUERYINFORMATIONPROCESS)(HANDLE ProcessHandle
            , int ProcessInformationClass, PVOID ProcessInformation
            , ULONG ProcessInformationLength, PULONG ReturnLength);

        int handleCount = -1;
        HMODULE lib = LoadLibrary("NTDLL.dll");
        if (NULL != lib) {
                NTQUERYINFORMATIONPROCESS NtQueryInformationProcess
                    = (NTQUERYINFORMATIONPROCESS)GetProcAddress(lib
                    , "NtQueryInformationProcess");
                if (NtQueryInformationProcess != NULL) {
                        HANDLE process = OpenProcess(PROCESS_QUERY_INFORMATION
                            , FALSE, ProcessId);
                        if (process != NULL) {
                                NtQueryInformationProcess(process, 20, &handleCount
                                    , sizeof(handleCount), NULL);
                                ::CloseHandle(process);
                        }
                }
                FreeLibrary(lib);
        }
        return handleCount;
}
//---------------------------------------------------------------------------
int GetPID()
{
        return ::GetCurrentProcessId();
}
//---------------------------------------------------------------------------
bool NewThread(void* lpFunAddr,void* lpParameter)
{
	HANDLE s = ::CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)lpFunAddr,lpParameter,0,NULL);
	if(NULL == s)
		return false;
	CloseHandle(s);
	return true;
}
//---------------------------------------------------------------------------
void RealSleep(unsigned int Ms)
{
        ::Sleep(Ms);//等到某天来写个准确时间
}
//==============================================================================
CriticalLock::CriticalLock()
    : m_Cs(new CRITICAL_SECTION)
{
        assert(m_Cs);
        InitializeCriticalSection((CRITICAL_SECTION*)m_Cs);
}
CriticalLock::~CriticalLock()
{
        DeleteCriticalSection((CRITICAL_SECTION*)m_Cs);
        delete (CRITICAL_SECTION*)m_Cs;
}
void CriticalLock::Lock() { EnterCriticalSection((CRITICAL_SECTION*)m_Cs); }
void CriticalLock::Free() { LeaveCriticalSection((CRITICAL_SECTION*)m_Cs); }
//==============================================================================
QDateTime::QDateTime()
    : m_Time(new SYSTEMTIME)
{
        assert(m_Time);
        Fresh();
}
QDateTime::~QDateTime()
{
        assert(m_Time);
        delete (SYSTEMTIME*)m_Time;
}
void QDateTime::Fresh(){::GetLocalTime((SYSTEMTIME*)m_Time);}
unsigned short QDateTime::Year()const{return ((SYSTEMTIME*)m_Time)->wYear;}
unsigned short QDateTime::Month()const{return ((SYSTEMTIME*)m_Time)->wMonth;}
unsigned short QDateTime::DayOfWeek()const{return ((SYSTEMTIME*)m_Time)->wDayOfWeek;}
unsigned short QDateTime::Day()const{return ((SYSTEMTIME*)m_Time)->wDay;}
unsigned short QDateTime::Hour()const{return ((SYSTEMTIME*)m_Time)->wHour;}
unsigned short QDateTime::Minute()const{return ((SYSTEMTIME*)m_Time)->wMinute;}
unsigned short QDateTime::Second()const{return ((SYSTEMTIME*)m_Time)->wSecond;}
unsigned short QDateTime::Milliseconds()const{return ((SYSTEMTIME*)m_Time)->wMilliseconds;}

std::string QDateTime::DateTimeString()const
{
	return LongToStr(Year()) + "-" + GetRightStr("00" + LongToStr(Month()),2)
            + "-" + GetRightStr("00" + LongToStr(Day()),2)
    	    + " " + GetRightStr("00" + LongToStr(Hour()),2)
            + ":" + GetRightStr("00" + LongToStr(Minute()),2)
            + ":" + GetRightStr("00" + LongToStr(Second()),2);
}
//---------------------------------------------------------------------------
int QDateTime::Cmp (const QDateTime& Dt) const
{
        if(((SYSTEMTIME*)m_Time)->wYear>((SYSTEMTIME*)Dt.m_Time)->wYear)
                return 1;
        if(((SYSTEMTIME*)m_Time)->wYear<((SYSTEMTIME*)Dt.m_Time)->wYear)
                return -1;
        if(((SYSTEMTIME*)m_Time)->wMonth>((SYSTEMTIME*)Dt.m_Time)->wMonth)
                return 1;
        if(((SYSTEMTIME*)m_Time)->wMonth<((SYSTEMTIME*)Dt.m_Time)->wMonth)
                return -1;
        if(((SYSTEMTIME*)m_Time)->wDay>((SYSTEMTIME*)Dt.m_Time)->wDay)
                return 1;
        if(((SYSTEMTIME*)m_Time)->wDay<((SYSTEMTIME*)Dt.m_Time)->wDay)
                return -1;

        if(((SYSTEMTIME*)m_Time)->wHour>((SYSTEMTIME*)Dt.m_Time)->wHour)
                return 1;
        if(((SYSTEMTIME*)m_Time)->wHour<((SYSTEMTIME*)Dt.m_Time)->wHour)
                return -1;
        if(((SYSTEMTIME*)m_Time)->wMinute>((SYSTEMTIME*)Dt.m_Time)->wMinute)
                return 1;
        if(((SYSTEMTIME*)m_Time)->wMinute<((SYSTEMTIME*)Dt.m_Time)->wMinute)
                return -1;
        if(((SYSTEMTIME*)m_Time)->wSecond>((SYSTEMTIME*)Dt.m_Time)->wSecond)
                return 1;
        if(((SYSTEMTIME*)m_Time)->wSecond<((SYSTEMTIME*)Dt.m_Time)->wSecond)
                return -1;
        if(((SYSTEMTIME*)m_Time)->wMilliseconds>((SYSTEMTIME*)Dt.m_Time)->wMilliseconds)
                return 1;
        if(((SYSTEMTIME*)m_Time)->wMilliseconds<((SYSTEMTIME*)Dt.m_Time)->wMilliseconds)
                return -1;
    return 0;
}
//---------------------------------------------------------------------------
QDateTime StrToDateTime(const std::string& Str)
{       //DayOfWeek数值无效
        QDateTime p;
        std::string Data=Str;
        ((SYSTEMTIME*)p.m_Time)->wYear=static_cast<unsigned short>(atoi(GetNext(Data,"-").c_str()));
        ((SYSTEMTIME*)p.m_Time)->wMonth=static_cast<unsigned short>(atoi(GetNext(Data,"-").c_str()));
        ((SYSTEMTIME*)p.m_Time)->wDay=static_cast<unsigned short>(atoi(GetNext(Data," ").c_str()));
        ((SYSTEMTIME*)p.m_Time)->wHour=static_cast<unsigned short>(atoi(GetNext(Data,"-").c_str()));
        ((SYSTEMTIME*)p.m_Time)->wMinute=static_cast<unsigned short>(atoi(GetNext(Data,"-").c_str()));
        ((SYSTEMTIME*)p.m_Time)->wSecond=static_cast<unsigned short>(atoi(GetNext(Data,"-").c_str()));
        ((SYSTEMTIME*)p.m_Time)->wMilliseconds=0;
        return p;
}
//==============================================================================
std::string QWndCopyData::Get(unsigned long LParam)
{
        COPYDATASTRUCT* data = (COPYDATASTRUCT*)LParam;
        return std::string((char*)data->lpData, data->cbData);
}
//---------------------------------------------------------------------------
unsigned long QWndCopyData::_Send(const std::string& Data, void* hWnd)
{
        COPYDATASTRUCT cpd;
        cpd.dwData = 0;
        cpd.cbData = Data.size()+1;
        cpd.lpData = (void*)Data.data();
        return SendMessage((HWND)hWnd, WM_COPYDATA, 0, (LPARAM)&cpd);
}
//---------------------------------------------------------------------------
unsigned long QWndCopyData::Send(const std::string& Data, const std::string& WinTitle)
{
        void* hWnd = ::FindWindow(NULL, WinTitle.c_str());
        if(NULL == hWnd)
                return 0;
        return _Send(Data, hWnd);
}
//---------------------------------------------------------------------------
QThread::QThread()
    :m_Working(false)
{
}
QThread::~QThread()
{
        this->Stop();
}
bool QThread::Start(void* Param)
{
        if(m_Working)
                return false;
        m_UserParam = Param;
        m_Pause     = false;
        m_CmdStop   =false;
        this->OnCreate();
        return NewThread(_thWork,this);
}
void QThread::Stop()
{
        m_CmdStop = true;
        while(m_Working)
                Sleep(10);
}
void QThread::PostStop()
{
        m_CmdStop = true;
}
bool QThread::IsPowerOn()const
{
        return m_Working;
}
bool QThread::IsCmdStop()const
{
        return m_CmdStop;
}
void QThread::Pause(bool Pause)
{
        m_Pause = Pause;
}
void QThread::DoPause()
{
        while(m_Pause && !m_CmdStop) { Sleep(100); }
}
int __stdcall _thWork(void* Param)
{
        QThread* Qt = (QThread*)Param;
        Qt->m_Working = true;
        try {
                Qt->Execute(Qt->m_UserParam);
        } catch(...) {
                MessageBox(NULL, "Exception raised in QThread at last!\r\n\r\n"
                    "The exception type is unknown!", "Exception raised in QThread"
                    , MB_ICONERROR);
                throw;
        }
        Qt->m_Working = false;
        Qt->OnDestroy();
        return 0;
}
//---------------------------------------------------------------------------
void QThread::OnCreate(){} //DO NONE
//---------------------------------------------------------------------------
void QThread::OnDestroy(){} //DO NONE
//---------------------------------------------------------------------------