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
 
#include <dcl/Object.h>
 
__DCL_BEGIN_NAMESPACE
 
class InternalMutex
{
public:
    // _name을위해 내부에서 메모리를 할당하지 않는다.
    // InternalMutext를 사용하는 곳에서 문자열을 유지해야 한다.
    InternalMutex(const char* _name);
    ~InternalMutex();
    void lock();
    void unlock();
private:
#if __DCL_PTHREAD
    pthread_mutex_t     __mutex;
#elif defined(__WINNT__)
    CRITICAL_SECTION    __cs;
#endif
    const char*         __name;
};
 
#if __DCL_HAVE_ALLOC_DEBUG
class AllocList
{
public:
    struct NodeBase
    {
        struct NodeBase*    prev;
        struct NodeBase*    next;
    };
 
#define __DCL_DEBUG_PATH_MAX    76
    struct Node : public NodeBase
    {
        thread_t        thread;         //   4   8
        char            pad;            //   5   9
        bool            check;          //   6  10
        DCLAllocFunc    func;           //   8  12
        char_t            filename[__DCL_DEBUG_PATH_MAX + 3 + 1]; // "..." + '\0'
                                        // 168 172 332
        unsigned int    line;           // 172 176 336
        size_t          size;           // 176 184 344
        void*           data;           // 180 192 352
 
        static size_t SIZE();
        void setFilename(const char_t* _filename);
        void* DATA() const;
    };
 
protected:
    NodeBase    __masterNode;
    size_t      __nodeCount;
 
    // _size 만큼을 할당하고 초기화된 노드 리턴
    // 메모리 할당할 수 없으면 NULL
    Node* allocNode(
        size_t _size, 
        bool _check, 
        DCLAllocFunc _func,
        const char_t* _filename,
        unsigned int _line
    );
 
    // 노드를 tail에 추가
    void* addTail(Node* _newNode);
 
public:
    // realloc 하고 초기화된 노드 리턴
    // 메모리 할당할 수 없으면 NULL
    Node* reallocNode(
        Node* _node,
        size_t _size,
        const char_t* _filename,
        unsigned int _line
    );
 
    AllocList();
    ~AllocList();
 
    // 리스트가 비어있으면 NULL
    Node* begin() const;
 
    // 리스트가 비어있으면 NULL
    Node* end() const;
 
    // 마지막 노드를 지나면 NULL, _node 리턴
    Node* next(Node*& _node) const;
 
    // 처음 노드를 지나면 NULL, _node 리턴
    Node* prev(Node*& _node) const;
 
    size_t count() const { return __nodeCount; }
 
    // 찾고자 하는 노드가 없으면 NULL
    // reverse 찾고자 하는 노드가 없으면 NULL
    Node* find(const void* _ptr) const;
    Node* rfind(const void* _ptr) const;            
 
    // _size malloc하고 노드를 tail에 추가
    // 메모리 할당할수 없으면 NULL
    void* allocAddTail(
        size_t _size,
        bool _check,
        DCLAllocFunc _func, 
        const char_t* _filename,
        unsigned int _line
    );
 
    // realloc 하고 노드 update
    // 메모리 할당할 수 없으면 NULL
    void* reallocUpdate(
        void* _ptr,
        size_t _size,
        bool _check,
        DCLAllocFunc _func,
        const char_t* _filename,
        unsigned int _line
    );
 
    // pNode를 삭제하고 메모리 해제
    void erase(Node* _node);
 
    // 전체 노드 삭제
    void clear();
};
#endif  // __DCL_HAVE_ALLOC_DEBUG
 
class PtrHashMap
{
public:
    struct NodeBase
    {
        struct NodeBase* prev;
        struct NodeBase* next;
    };
 
    struct Node : public NodeBase
    {
        const void* key;
        const void* value;
    };
 
protected:
    size_t bucketIndex(const void* _key) const;
 
public:
    PtrHashMap(size_t _buckerCount);
    ~PtrHashMap();
 
    const void*& operator [] (const void* _key);
 
    // 찾지 못하면 NULL
    Node* find(const void* _key) const;
 
    // find의 리턴값
    void erase(Node* _node);
 
    size_t count() const;
 
protected:
    NodeBase*   __buckets;
    size_t      __bucketCount;
    size_t      __nodeCount;
};
 
inline size_t PtrHashMap::bucketIndex(const void* _key) const
{
    return (size_t)_key % __bucketCount;
}
 
inline size_t PtrHashMap::count() const
{
    return __nodeCount;
}
 
struct LibState
{
    InternalMutex      lockSQLDriverPool;     // for SQLDriver in SQLDriver.cpp
    DCLCleanupCallback    pfnSQLCleanup;
#ifdef __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__