个人基础库

基础库___日志输出

晓寒 — Tue, 15 Aug 2006 08:35:00 GMT

类图：

序列图：

下面是代码：
CHLogger.h

/**
*  @file     CHLogger.h
*  @class    CHLogger
*  @author   flyingleaf
*  @version  1.0.0.0
*  @date     2006-08-11
*  @brief    您可以任使用此文件，但是需要保留本声明
*  @notice   1、使用<<输出日志时没有时间戳
             2、logger和使用的stream之间是关联：logger不负责stream的生命周期
*/

#ifndef _XHJ_CHLogger_h_
#define _XHJ_CHLogger_h_

#include <string>
#include <fstream>
#include <CHMutex.h>
#include <CHStream.h>
#include <vector>
#include <CHTime.n>

using namespace std;

namespace XHJ
{
    class CHLogger
    {
    public:
        //日志级别
        typedef enum
        {
            InfoLevel    = 1,    //信息级别
            WarningLevel = 2,    //告警级别
            ErrorLevel   = 4     //error级别
        }LogLevel;

        CHLogger(const char* fileName = "CHLogger.debug"):
            m_LogLevel(LogLevel::InfoLevel)
        {
        }

        ~CHLogger()
        {
        }

        void AddStream(CHLogStream*);
        void RemoveStream(const CHLogStream*);
        void ClearStream();

        virtual void Info(const string&);
        virtual void Warning(const string&);
        virtual void Error(const string&);

        //设置告警级别
        void SetLogLevel(const LogLevel& );

        //只有信息级别的时候,通过该接口的信息才能够显示
        CHLogger& operator << ( const string& );

        CHLogger& operator << ( ostream& (&)(ostream&) );

    protected:
        void WriteLog(const string&, const LogLevel& level = InfoLevel);

    private:
        LogLevel m_LogLevel;       //告警级别

        vector<CHLogStream*> m_Streams;
        CHMutex m_instanceMutex;
    };

}
#endif

CHLogger.cpp

#include "StdAfx.h"
#include "CHlogger.h"

namespace XHJ
{
    //可以添加重复的
    void CHLogger::AddStream(CHLogStream* stream)
    {
        Lock lock(m_instanceMutex);

        m_Streams.push_back(stream);
    }

    //删除所有同名字的
    void CHLogger::RemoveStream(const CHLogStream* stream)
    {
        Lock lock(m_instanceMutex);

        vector<CHLogStream*>::iterator pos = m_Streams.begin();
        for( ;    pos != m_Streams.end();    )
        {
            if((*pos)->StreamName() == stream->StreamName())
            {
                pos = m_Streams.erase(pos);
                continue;
            }

            ++pos;
        }
    }

    void CHLogger::ClearStream()
    {
        Lock lock(m_instanceMutex);

        m_Streams.clear();
    }

    void CHLogger::WriteLog(const string& message,const LogLevel& level)
    {
        //告警级别不够的，不输出
        if(level < m_LogLevel) return;

        for(vector<CHLogStream*>::iterator pos = m_Streams.begin();
            pos != m_Streams.end();
            ++pos)
        {
            (*pos)->WriteData(message.c_str());
        }
    }

    void CHLogger::SetLogLevel(const LogLevel& level)
    {
        Lock lock(m_instanceMutex);

        m_LogLevel = level;
    }

    void CHLogger::Info(const string& message)
    {
        Lock sync(m_instanceMutex);

        WriteLog(CHTime::now().toString() + " info:    " + message);
    }

    CHLogger  & CHLogger::operator << ( const string& message)
    {
        Lock lock(m_instanceMutex);

        WriteLog(message);

        return *this;
    }

    CHLogger& CHLogger::operator << ( ostream& (&)(ostream&) )
    {
        Lock lock(m_instanceMutex);

        WriteLog(" ");

        return (*this);
    }

    void CHLogger::Warning(const string& message)
    {
        Lock sync(m_instanceMutex);

        WriteLog(CHTime::now().toString() + " warning: " + message,WarningLevel);
    }

    void CHLogger::Error(const string& message)
    {
        Lock sync(m_instanceMutex);

        WriteLog(CHTime::now().toString() + " error:   " + message , ErrorLevel);
    }
}

CHLogStream.h 没有cpp

/**
*  @file     CHLogStream.h
*  @class    CHLogStream
*  @author   flyingleaf
*  @version  1.0.0.0
*  @date     2006-08-11
*  @brief    您可以任使用此文件，但是需要保留本声明
*/

#ifndef _XHJ_CHStream_h_
#define _XHJ_CHStream_h_
#include <windows.h>
#include <string>

using namespace std;

namespace XHJ
{
    class CHLogStream
    {
    public:
        CHLogStream(void) { m_StreamName = "CHLogStream" ;}
        virtual ~CHLogStream(void){};

        virtual void Init()=0;
        virtual void WriteData(const char*)=0;
        virtual void WriteData(void*)=0;

        string StreamName()const { return m_StreamName;}
        void SetStreamName(const string& name) { m_StreamName = name;}

    private:
        string m_StreamName;
    };

    class CHConLogStream:public CHLogStream
    {
    public:
        CHConLogStream(const string& name = "CHConLogStream")
        {
            SetStreamName(name);
        }

        void Init()
        {
        }

        void WriteData(const char* data)
        {
            cout << data;
        }

        void WriteData(void* data)
        {
            cout << data;
        }
    };
}
#endif

CHTime在评论中贴，否则篇幅过长，怕贴不出来了：P

基础库___监测类框架

晓寒 — Wed, 09 Aug 2006 06:44:00 GMT

监测类的框架,使用了一个回调模式.可以回调普通函数和成员函数。
特别说明：该代码是我当时使用的，因为我使用的是成员函数，所以就使用了模版。但是这也带来了问题：如果用户仅仅使用普通函数作为回调的话，就很不方便。所以，如果想仅仅使用普通函数的话，需要把该类一分为二：把实现普通回调和成员回调分开。
特别鸣谢：[jzhang]、[hpho]两位朋友的建议和意见。
代码如下:

/**
*  @file     CHMonitor.h
*  @class    CHMonitor
*  @author   flyingleaf
*  @version  1.0.0.0
*  @date     2005-07-26
*  @brief    您可以任使用此文件，但是需要保留本声明
*/

#ifndef _XHJ_CHMONITOR_H_
#define _XHJ_CHMONITOR_H_
#include <windows.h>

template <class T>
class CHMonitor
{
public:
    CHMonitor():m_MemberFunction(0)，m_DelegaterHandle(0){};
    virtual ~CHMonitor(){};

private:
    typedef  void  (*DelegaterHandle)();
    typedef  void  (T::*TMemberFunctionPointer)();

public:
    //开始监测
    virtual int StartMonitor() = 0;

    //停止监测
    virtual BOOL StopMonitor() = 0;

    //挂起监测
    virtual BOOL SuspendMonitor() = 0;

    //继续监测
    virtual BOOL ResumeMonitor() = 0;

    virtual void SetCallBackHandle(DelegaterHandle handle) { m_DelegaterHandle = handle;}

    virtual void SetCallbackFunction(T* host, TMemberFunctionPointer memberFunction)
    {
        m_spHost = host;
        m_MemberFunction = memberFunction;
    }


    virtual void InvokeHandle()
    {
        if(m_DelegaterHandle)
            m_DelegaterHandle();
        if(m_MemberFunction)
        {
            ((static_cast<T*>(m_spHost)->*m_MemberFunction)());
        }
    }

protected:

    DelegaterHandle m_DelegaterHandle;
    T* m_spHost;
    TMemberFunctionPointer m_MemberFunction;
};

#endif

别看了.完了.cpp没有内容
别怕头晕,我来一个实现:

*  @file     CHProcessMonitor.h
*  @class    CHProcessMonitor
*  @author   flyingleaf
*  @version  1.0.0.0
*  @date     2006-08-08
*  @brief    您可以任使用此文件，但是需要保留本声明
*/

#ifndef _XHJ_CHWMIMONITOR_H_
#define _XHJ_CHWMIMONITOR_H_
#include "CHWmi.h"
#include "CHMonitor.h"
#include <string>
#include <CHMutex.h>

using namespace std;
using namespace XHJ;

template <class T>
class CHProcessMonitor : public CHMonitor<T>
{
public:
    CHProcessMonitor()
    {
    }

    //参数分别是IP，用户名，密码，wql语句。
    //如果是本机，则ip为127.0.0.1，用户名和密码都可以为空。
    CHProcessMonitor(const char* wql,const char* ip = "127.0.0.1",
        const char* username = "", const char* psw="" )
    {
        m_Wql      = wql;
        m_IP       = ip;
        m_UserName = username;
        m_Psw      = psw;
  m_EventHandle     = NULL;
  m_ThreadHandle    = NULL;
    }
    ~CHProcessMonitor()
    {
    }
public:
    //开始监测
    int StartMonitor()
    {
  m_EventHandle = CreateEvent(NULL,FALSE,FALSE,"XHJ_CHProcessMonitor_Event");
  if(m_EventHandle == NULL)
  {
   return -3;
  }
        m_ThreadHandle = CreateThread(NULL, 0, ThreadFuncNotify, (void*)this, 0, 0);
        if(m_ThreadHandle == NULL)
        {
            return -4;
        }
        return 0;
    }

    //停止监测
    BOOL StopMonitor()
    {
  Lock lock(m_Mutex);
        SetEvent(m_EventHandle);
        return TRUE;
    }
    //挂起监测
    BOOL SuspendMonitor()
    {
        if(SuspendThread(m_ThreadHandle) == 0xFFFFFFFF) return FALSE;
        return TRUE;
    }
    //继续监测
    BOOL ResumeMonitor()
    {
        if(ResumeThread (m_ThreadHandle) == 0xFFFFFFFF) return FALSE;
        return TRUE;
    }
    const char* GetUserName() const { return m_UserName.c_str();}
    const char* GetIP() const { return m_IP.c_str();    }
    const char* GetPsw() const { return m_Psw.c_str();    }
    const char* GetWql() const { return m_Wql.c_str();    }
    void SetIP(const char* ip) { m_IP = ip;    }
    void SetUserName(const char* username) { m_UserName = username;}
    void SetPsw(const char* psw) { m_Psw = psw;}
    void SetWql(const char* wql) { m_Wql = wql;    }
protected:
    //监测线程
    static DWORD WINAPI ThreadFuncNotify( LPVOID lpParam )
    {
        CHProcessMonitor* monitor = (CHProcessMonitor*)lpParam;
        IEnumWbemClassObject* m_pEnum = NULL;
        if(monitor->m_Wql.length() == 0) return -7;
        CHWMI* m_CHWMIHandle = new CHWMI;
        if(m_CHWMIHandle == NULL) return -1;
        int ret = m_CHWMIHandle->Connect(monitor->m_IP,monitor->m_UserName, monitor->m_Psw);
        if(ret != CWMI_RET_OK)
        {
            delete m_CHWMIHandle;
            return -2;
        }
        IWbemClassObject*  pObject = NULL;
        ret = m_CHWMIHandle->WMINotificationQuery(monitor->m_Wql, &m_pEnum,&pObject);
        if(ret != CWMI_RET_OK)
        {
            if(pObject)
                pObject->Release();
            delete m_CHWMIHandle;
            return -3;
        }

        while(WaitForSingleObject(monitor->m_EventHandle, 0) != WAIT_OBJECT_0)
        {
            ret = m_CHWMIHandle->EnumInstanceNext(m_pEnum,
                    &pObject,500);
            if(ret == CWMI_RET_OK)
            {
                monitor->InvokeHandle();
                if(pObject)
                    pObject->Release();
                pObject = NULL;
            }
        }
        m_CHWMIHandle->EnumInstanceEnd(m_pEnum);
        if(pObject)
            pObject->Release();
        if(m_CHWMIHandle)
            delete m_CHWMIHandle;
        return 0;
    }
private:
    string m_Wql;
    string m_IP;
    string m_UserName;
    string m_Psw;
HANDLE m_EventHandle;
    HANDLE m_ThreadHandle;
    CHWMI* m_CHWMIHandle;
CHMutex m_Mutex;
    IEnumWbemClassObject* m_pEnum;
};
#endif

附带wmi的简单封装

/**
*  @file     CHWMI.h
*  @class    CHWMI
*  @author   flyingleaf
*  @version  1.0.0.0
*  @date     2005-05-09
*  @brief    您可以任使用此文件，但是需要保留本声明
*/

#ifndef _XHJ_CHWMI_H_
#define _XHJ_CHWMI_H_

// 如果您必须使用下列所指定的平台之前的平台，则修改下面的定义。
// 有关不同平台的相应值的最新信息，请参考 MSDN。
#ifndef WINVER                // 允许使用 Windows 95 和 Windows NT 4 或更高版本的特定功能。
#define WINVER 0x0400        //为 Windows98 和 Windows 2000 及更新版本改变为适当的值。
#endif

#ifndef _WIN32_WINNT        // 允许使用 Windows NT 4 或更高版本的特定功能。
#define _WIN32_WINNT 0x0400        //为 Windows98 和 Windows 2000 及更新版本改变为适当的值。
#endif

#ifndef _WIN32_WINDOWS        // 允许使用 Windows 98 或更高版本的特定功能。
#define _WIN32_WINDOWS 0x0410 //为 Windows Me 及更新版本改变为适当的值。
#endif

#ifndef _WIN32_IE            // 允许使用 IE 4.0 或更高版本的特定功能。
#define _WIN32_IE 0x0400    //为 IE 5.0 及更新版本改变为适当的值。
#endif

#include <Atlbase.h>
#include <Wbemidl.h>
#include <string>

#define CWMI_RET_OK 0
#define CWMI_RET_ERROR -1
#define CWMI_RET_ERROR_HRESULT -2
#define CWMI_RET_ERROR_DEFINE -3
#define CWMI_RET_TIMEOUT   -4

#define CWMI_ENUM_CREAT 1
#define CWMI_ENUM_QUERY 2

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

    int Connect(const std::string szHost, const std::string szUserName, const std::string szPsw );
    int EnumInstanceEnd(IEnumWbemClassObject *IEnum);
    int EnumInstanceNext(IEnumWbemClassObject *IEnum,
                            IWbemClassObject **pObject,
                            int timeout = WBEM_INFINITE);

    int WMINotificationQuery(const std::string& Querystdstring,
        IEnumWbemClassObject **ppEnum, IWbemClassObject **pObject);

protected:
    // WMI服务器指针
    IWbemServices * m_pIWbemServices;

private:
    // 用于身份验证
    std::string m_csHost;
    std::string m_csUsername;
    std::string m_csPassword;

    std::string m_csDefaultNameSpace;
};
#endif

#include "CHTWmi.h"

#include <Iphlpapi.h>
#include <Winsock2.h>

#include <objbase.h>
#pragma comment(lib, "Wbemuuid.lib")
#pragma comment(lib, "ole32.lib")

#pragma warning(disable:4267)

CHWMI::CHWMI()
{
    ::CoInitialize(NULL);
    m_csDefaultNameSpace = "\ROOT\CIMV2";
}

CHWMI::~CHWMI()
{
    ::CoUninitialize();
}

int CHWMI::Connect(const std::string szHost,
                   const std::string szUserName,
                   const std::string szPsw )
{
    HRESULT        hres;
    IWbemLocator *pIWbemLocator;
    hres = CoCreateInstance    ( CLSID_WbemLocator, 0,
        CLSCTX_INPROC_SERVER, IID_IWbemLocator    ,
        (LPVOID *) &pIWbemLocator    );

    if (FAILED(hres))
    {
        return CWMI_RET_ERROR_DEFINE;
    }

    m_csHost = szHost;
    m_csUsername = szUserName;
    m_csPassword = szPsw;

    std::string csWMINameSpace = "\\";
    csWMINameSpace += m_csHost;
    csWMINameSpace += m_csDefaultNameSpace;
    CComBSTR bstrNamespace(csWMINameSpace.c_str());

    if ( m_csUsername.empty())
    {
        hres = (pIWbemLocator)->ConnectServer(bstrNamespace, NULL, NULL    ,
            0, NULL, 0, 0, &m_pIWbemServices    );
    }
    else
    {
        CComBSTR bstrUsername(m_csUsername.c_str()), bstrPassword(m_csPassword.c_str());

        hres = (pIWbemLocator)->ConnectServer(bstrNamespace, bstrUsername,
            bstrPassword, 0, NULL, 0, 0,
            &m_pIWbemServices    );
    }

    if (FAILED(hres))
    {
        (pIWbemLocator)->Release();
        return CWMI_RET_ERROR_DEFINE;
    }

    std::string username,domain;
    username = m_csUsername;
    domain = "";

    SEC_WINNT_AUTH_IDENTITY AuthInfo;
    AuthInfo.User = (unsigned char *)(LPCTSTR)username.c_str();
    AuthInfo.Password = (unsigned char *)(LPCTSTR)m_csPassword.c_str();
    AuthInfo.Domain = (unsigned char *)(LPCTSTR)domain.c_str();
    AuthInfo.UserLength = m_csUsername.length();
    AuthInfo.DomainLength = 0;
    AuthInfo.PasswordLength = m_csPassword.length();
    AuthInfo.Flags = SEC_WINNT_AUTH_IDENTITY_ANSI;

    hres = CoSetProxyBlanket( m_pIWbemServices    ,
        RPC_C_AUTHN_WINNT    ,
        RPC_C_AUTHZ_NONE    ,
        NULL,
        RPC_C_AUTHN_LEVEL_CALL        ,
        RPC_C_IMP_LEVEL_IMPERSONATE    ,
        &AuthInfo,
        EOAC_NONE);

    if(FAILED(hres))
    {
        (pIWbemLocator)->Release();
        (m_pIWbemServices)->Release();
        m_pIWbemServices = NULL;
        return CWMI_RET_ERROR_DEFINE;
    }

    (pIWbemLocator)->Release();

    return CWMI_RET_OK;
}

int CHWMI::EnumInstanceNext(IEnumWbemClassObject *pIEnum,
                            IWbemClassObject **ppIObject,
                            int timeout)
{
    if( !m_pIWbemServices )
    {
        return CWMI_RET_ERROR_DEFINE;
    }

    ULONG            uReturned;

    if(*ppIObject != NULL)
        (*ppIObject)->Release();

    HRESULT hres = pIEnum->Next(timeout, 1, ppIObject, &uReturned );

    if ( SUCCEEDED( hres ) && uReturned == 1)
        return CWMI_RET_OK;
    else if(hres == WBEM_S_TIMEDOUT)
        return CWMI_RET_TIMEOUT;
    else
        return CWMI_RET_ERROR;
}

int CHWMI::EnumInstanceEnd(IEnumWbemClassObject *pIEnum)
{
    pIEnum->Release();

    return CWMI_RET_OK;
}
int CHWMI::WMINotificationQuery(const std::string& QueryString,
                                IEnumWbemClassObject **ppEnum,
                                IWbemClassObject **ppObject)
{
    CComBSTR        bstrQueryString(QueryString.c_str());
    CComBSTR        bstrWQL("WQL");

    *ppObject = NULL;
    HRESULT hres;
    hres = m_pIWbemServices->ExecNotificationQuery(
        bstrWQL,
        bstrQueryString,
        WBEM_FLAG_RETURN_IMMEDIATELY | WBEM_FLAG_FORWARD_ONLY ,
        NULL,
        ppEnum
        );
    if(hres == WBEM_S_NO_ERROR)
    {
        std::string username,domain;
        username = m_csUsername;
        domain = "";

        SEC_WINNT_AUTH_IDENTITY AuthInfo;
        AuthInfo.User = (unsigned char *)(LPCTSTR)username.c_str();
        AuthInfo.Password = (unsigned char *)(LPCTSTR)m_csPassword.c_str();
        AuthInfo.Domain = (unsigned char *)(LPCTSTR)domain.c_str();
        AuthInfo.UserLength = m_csUsername.length();
        AuthInfo.DomainLength = 0;
        AuthInfo.PasswordLength = m_csPassword.length();
        AuthInfo.Flags = SEC_WINNT_AUTH_IDENTITY_ANSI;

        HRESULT hres = CoSetProxyBlanket( *ppEnum    ,
            RPC_C_AUTHN_WINNT    ,
            RPC_C_AUTHZ_NONE    ,
            NULL,
            RPC_C_AUTHN_LEVEL_CALL        ,
            RPC_C_IMP_LEVEL_IMPERSONATE    ,
            &AuthInfo,
            EOAC_NONE);

        if(FAILED(hres))
        {
            (*ppEnum)->Release();

            return CWMI_RET_ERROR_DEFINE;
        }
        return CWMI_RET_OK;
    }
    else
        return CWMI_RET_ERROR;
}

基础库___智能指针

晓寒 — Wed, 26 Jul 2006 03:22:00 GMT

CHObject中实现了引用计数。用以配合智能指针(CHSmartPointer)的实现。CHObject类的设计中，构造函数设定为protected，不再允许用户直接进行new操作，而是让用户从静态函数::New()来构造,采取这一策略主要是为了配合智能指针的使用，使得用户不必考虑初始引用计数的繁琐问题，简化构造过程。

基础库___异常类

晓寒 — Tue, 25 Jul 2006 09:37:00 GMT

基础库___锁

晓寒 — Tue, 25 Jul 2006 09:35:00 GMT