LibState.h

Go to the documentation of this file.

#ifndef __DCL_LIB_STATE_H__
#define __DCL_LIB_STATE_H__     20061115
 
#ifndef __DCL_CONFIG_H__
#include <dcl/_Config.h>
#endif
 
#if __DCL_PTHREAD
#include <pthread.h>
#endif
 
#include <dcl/Object.h>
 
__DCL_BEGIN_NAMESPACE
 
class InternalMutex
{
public:
    // pszName을위해 내부에서 메모리를 할당하지 않는다.
    // InternalMutext를 사용하는 곳에서 문자열을 유지해야 한다.
    InternalMutex(const char* pszName);
    ~InternalMutex();
    void lock();
    void unlock();
private:
#if __DCL_PTHREAD
    pthread_mutex_t     m_mutex;
#elif __DCL_WINDOWS
    CRITICAL_SECTION    m_cs;
#endif
    const char* m_pszName;
};
 
#if __DCL_HAVE_ALLOC_DEBUG
 
#define __DCL_DEBUG_PATH_MAX    76
 
class AllocList
{
public:
    struct NodeBase
    {
        struct NodeBase*    pPrev;
        struct NodeBase*    pNext;
    };
 
    struct Node : public NodeBase
    {
        unsigned long       uThreadId;          // 4
        bool                bCheck;             // 8
        DCLAllocFunction    allocFunction;      // 12
        char_t                szFileName[__DCL_DEBUG_PATH_MAX + 3 + 1]; // "..." + '\0' 148, 172, 332
        unsigned int        nLine;              // 152
        size_t              nSize;              // 158
 
        static size_t size();
        void assignFileName(const char_t* _filename);
        void* data() const;
    };
 
protected:
    NodeBase    m_masterNode;
    size_t      m_nCount;
 
    // nSize 만큼을 할당하고 초기화된 노드 리턴
    // 메모리 할당할 수 없으면 NULL
    Node* allocNode(size_t nSize, 
                bool bCheck, 
                DCLAllocFunction allocFunction,
                const char_t* _filename,
                unsigned int _line);
 
    // 노드를 tail에 추가
    void* addTail(Node* pNewNode);
 
public:
    // realloc 하고 초기화된 노드 리턴
    // 메모리 할당할 수 없으면 NULL
    Node* reallocNode(Node* pNode,
                size_t nSize,
                const char_t* _filename,
                unsigned int _line);
 
    AllocList();
    ~AllocList();
 
    // 리스트가 비어있으면 NULL
    Node* begin() const;
 
    // 리스트가 비어있으면 NULL
    Node* end() const;
 
    // 마지막 노드를 지나면 NULL, pNode 리턴
    Node* next(Node*& pNode) const;
 
    // 처음 노드를 지나면 NULL, pNode 리턴
    Node* prev(Node*& pNode) const;
 
    size_t count() const { return m_nCount; }
 
    // 찾고자 하는 노드가 없으면 NULL
    // reverse 찾고자 하는 노드가 없으면 NULL
    Node* find(const void* p) const;
    Node* rfind(const void* p) const;           
 
    // nSize malloc하고 노드를 tail에 추가
    // 메모리 할당할수 없으면 NULL
 
    void* allocAddTail(
                size_t nSize,
                bool bCheck,
                DCLAllocFunction allocFunction, 
                const char_t* _filename,
                unsigned int _line
                );
 
    // realloc 하고 노드 update
    // 메모리 할당할 수 없으면 NULL
    void* reallocUpdate(
                void* p,
                size_t nSize,
                bool bCheck,
                DCLAllocFunction allocFunction,
                const char_t* _filename,
                unsigned int _line
                );
 
    // pNode를 삭제하고 메모리 해제
    void erase(Node* pNode);
 
    // 전체 노드 삭제
    void clear();
};
 
#endif  // __DCL_HAVE_ALLOC_DEBUG
 
class PtrHashMap
{
public:
    struct NodeBase
    {
        struct NodeBase* pPrev;
        struct NodeBase* pNext;
    };
 
    struct Node : public NodeBase
    {
        const void* key;
        const void* value;
    };
 
protected:
    size_t bucketNumber(const void* key) const;
        
public:
    PtrHashMap(size_t nBuckets);
    ~PtrHashMap();
 
    const void*& operator [] (const void* key);
 
    // 찾지 못하면 NULL
    Node* find(const void* key) const;
 
    // find의 리턴값
    void erase(Node* pNode);
 
    size_t count() const;
 
protected:
    NodeBase*   m_buckets;
    size_t          m_nBuckets;
    int             m_nCount;
};
 
inline size_t PtrHashMap::bucketNumber(const void* key) const
{
    return (size_t)key % m_nBuckets;
}
 
inline size_t PtrHashMap::count() const
{
    return m_nCount;
}
 
struct LibState
{
    InternalMutex      lockSQLDriverPool;     // for SQLDriver in SQLDriver.cpp
    DCLCleanupCallback    pfnSQLCleanup;
#if __DCL_DEBUG
    InternalMutex      lockGlobalOutput;
#define MAP_THREAD_OUTPUT_BUCKET_COUNT  50
    PtrHashMap            mapThreadOutput;
    InternalMutex      lockThreadOutput;
#if __DCL_HAVE_ALLOC_DEBUG
    AllocList           listAlloc;
    InternalMutex      lockAlloc;
#endif  // __DCL_HAVE_ALLOC_DEBUG
 
#endif
 
    LibState();
    ~LibState();
};
 
__DCL_END_NAMESPACE
 
#endif      // __DCL_LIB_STATE_H__