Object.h

Go to the documentation of this file.

#ifndef __DCL_OBJECT_H__
#define __DCL_OBJECT_H__        20050517
 
#ifndef __cplusplus
#error "dcl/Object.h requires C++ Complilation"
#endif
 
#ifndef __DCL_CONFIG_H__
#include <dcl/Config.h>
#endif
 
#ifdef __WINNT__
    #if __DCL_PTHREAD
        #include <pthread.h>
        typedef pthread_t thread_t;
    #else
        typedef unsigned long thread_t;
    #endif
#else
    #if defined(__linux__)
        #include <bits/pthreadtypes.h>
    #elif defined(__APPLE__)
        #include <sys/_pthread/_pthread_types.h>
    #else
        #include <pthread.h>
    #endif
    typedef pthread_t thread_t;
#endif
 
#ifndef __DCL_NO_RTTI
#include <typeinfo>
#endif
 
#if __DCL_HAVE_ALLOC_DEBUG && !(__DCL_DEBUG)
#error "dcl/_Config.h incorrect"
#endif
 
#ifdef __DCL_DEBUG_NEW
#error "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
#undef new
#endif
 
#undef __CONCAT__
#undef __CONCAT
 
#undef __STRING__
 
#undef __TEXT__
#undef __TEXT
#undef __T
#undef _T
 
#define __CONCAT__(x, y)            x ## y
#define __CONCAT(x, y)              __CONCAT__(x, y)
 
#define __STRING__(expr)            #expr
 
#define __TEXT__(str)               L ## str
#define __TEXT(str)                 __TEXT__(str)
#define __T(str)                    __TEXT__(str)
#define _T(str)                     __TEXT__(str)
 
#define __CONCAT_TEXT(str, expr)    __TEXT(str) __STRING__(expr)
 
#if 0
// Test text-macros
#define BB bb
 
__CONCAT(aa, BB)
__STRING__(aa == b)
 
__TEXT("aa")
__T("aa")
 
__CONCAT_TEXT("aa", BB)
#endif
 
__DCL_BEGIN_NAMESPACE
 
/*
DCLCore classes
 
Object;
    Exception;
        IOException;
        DllException;
        AssertError;
        SQLException;
    InputStream;
        FileInputStream;
    OutputStream;
        ByteOutputStream;
            XByteOutputStream;
        FileOutputStream;
            XFileOutputStream;
    File;
    StdFile;
    Thread;
        MThread;    // Message
    Dll;
        SQLDriver;
    SQLField;
        SQLParam;
    SQLQuery;
    SQLConnection;
    SQLConnectionPool;
    HtmlTemplate;
    IniFile;
#ifdef __WINNT__
    Registry;
#endif
    Regex;
    Writer;
 
String;
Date;
Time;
DateTime;
Interval;
Int32;
Int64;
Single;
Double;
Decimal;
 
SyncObject;
    Mutex;
    ThreadCond;
*/
 
class String;
class Writer;
 
class DCLCAPI Object
{
protected:
    virtual ~Object();
    Object();
 
public:
    virtual String toString() const;
 
#ifdef __DCL_DEBUG
    virtual void dump(Writer& _out) const;
#endif
    virtual void destroy();
 
#if __DCL_HAVE_ALLOC_DEBUG
    void* operator new(
        size_t          _size,
        bool            _check,
        const char_t* _filename,
        unsigned int    _line
    );
 
    void* operator new[](
        size_t          _size,
        bool            _check,
        const char_t* _filename,
        unsigned int    _line
    );
 
    void operator delete(
        void*           _ptr,
        bool,           // _check
        const char_t* _filename,
        unsigned int    _line
    ) noexcept;
 
    void operator delete[](
        void*           _ptr,
        bool,           // _check
        const char_t* _filename,
        unsigned int    _line
    ) noexcept;
 
    void* operator new(size_t);
    void* operator new[](size_t);
 
    void operator delete(void* _ptr) noexcept;
    void operator delete[](void* _ptr) noexcept;
 
    // default placement
    void* operator new(size_t, void* _ptr) { return _ptr; }
    void* operator new[](size_t, void* _ptr) { return _ptr; }
    void operator delete(void*, void*) noexcept { }
    void operator delete[](void*, void*) noexcept { }
#endif
 
public:
    String className() const;
 
#ifdef __DCL_NO_RTTI
    struct DCLCAPI ClassInfo
    {
        const wchar_t*      pszClassName;
        size_t              nObjectSize;
        const ClassInfo*    pBaseClassInfo;
    };
    static const ClassInfo __classInfo;
 
    // 인스턴스의 클래스가 pClassInfo이거나 pClassInfo로부터 상속받은 클래스이면 true
    bool isKindOf(const ClassInfo* pClassInfo) const;
    // pClassInfo의 인스턴스이면 true
    bool isInstanceOf(const ClassInfo* pClassInfo) const;
    virtual const ClassInfo* classInfo() const;
#else
    bool isInstanceOf(const std::type_info& typeinfo) const;
    virtual const std::type_info& typeInfo() const;
#endif
};
 
#ifdef __DCL_NO_RTTI
#define CLASSINFO_REF   const Object::ClassInfo*
#define CLASSINFO(class_name) (&class_name::__classInfo)
#define DECLARE_CLASSINFO(class_name) \
public: \
    static const ClassInfo __classInfo; \
    virtual const ClassInfo* classInfo() const;
#else
#define CLASSINFO_REF   const std::type_info&
#define CLASSINFO(class_name) (typeid(class_name))
#define DECLARE_CLASSINFO(class_name) \
public: \
    virtual const std::type_info& typeInfo() const; 
#endif
 
#ifdef __DCL_NO_RTTI
#define IMPLEMENT_CLASSINFO(class_name, base_class_name) \
const Object::ClassInfo class_name::__classInfo = \
{ \
    __DCL_NAMESPACE_STRING __S(class_name), \
    sizeof(class class_name), \
    &base_class_name::__classInfo \
}; \
const Object::ClassInfo* class_name::classInfo() const \
{ \
    return CLASSINFO(class_name); \
}
#else
#define IMPLEMENT_CLASSINFO(class_name, base_class_name) \
const std::type_info& class_name::typeInfo() const \
{ \
    return typeid(class_name); \
}
#endif
 
__DCL_END_NAMESPACE
 
#ifdef __DCL_DEBUG
#define DCLInitialize   DCLInitializeD
#define DCLCleanup      DCLCleanupD
#endif
 
#if __DCL_HAVE_MANUAL_INITIALIZE
DCLCAPI int DCLInitialize();

DCLCAPI void DCLCleanup();
 
#define __DCL_INITIALIZE    DCLInitialize();
#define __DCL_CLEANUP       DCLCleanup();
#else
#define __DCL_INITIALIZE
#define __DCL_CLEANUP
#endif
 
//typedef void (* DCLCleanupCallback)(void*);
typedef void (* DCLCleanupCallback)();
 
#ifdef __DCL_DEBUG
DCLCAPI __DCL_NAMESPACE Writer* DCLDebugSetGlobalReport(
    __DCL_NAMESPACE Writer* __noclose__ _pWriter
);

DCLCAPI __DCL_NAMESPACE Writer* DCLDebugSetThreadReport(
    thread_t _threadId,
    __DCL_NAMESPACE Writer* __noclose__ _pWriter
);

DCLCAPI void DCLDebugAssert(
    const char_t* _filename, 
    unsigned int    _line,
    const char_t* _expr,
    const char_t* _message
) __DCL_THROWS1(__DCL_NAMESPACE AssertError*);

DCLCAPI void DCLDebugTrace(
    const char_t* _filename,
    unsigned int    _line,
    const char_t* _format,
    ...
);
#endif      /*  __DCL_DEBUG */
 
/*****************************************************
    MACRO FOR ASSERT/TRACE
*****************************************************/
 
#undef ASSERT
#undef ASSERT_EX
#undef VERIFY
 
#define ASSERT      __DCL_ASSERT
#define ASSERT_EX   __DCL_ASSERT_EX
#define VERIFY      __DCL_VERIFY
 
#undef TRACE0
#undef TRACE1
#undef TRACE2
#undef TRACE3
#undef TRACE4
#undef TRACE5
#undef TRACE6
 
#define TRACE0      __DCL_TRACE0
#define TRACE1      __DCL_TRACE1
#define TRACE2      __DCL_TRACE2
#define TRACE3      __DCL_TRACE3
#define TRACE4      __DCL_TRACE4
#define TRACE5      __DCL_TRACE5
#define TRACE6      __DCL_TRACE6
 
#ifdef __DCL_DEBUG
 
#define __DCL_ASSERT(expr) \
    (expr) ? (void) 0 : DCLDebugAssert(__THIS_FILE__, __LINE__, __T(#expr), NULL)
 
#define __DCL_ASSERT_EX(expr, msg) \
    (expr) ? (void) 0 : DCLDebugAssert(__THIS_FILE__, __LINE__, __T(#expr), msg)
 
#define __DCL_VERIFY(expr) __DCL_ASSERT(expr)
 
#define __DCL_TRACE0(psz) \
    DCLDebugTrace(__THIS_FILE__, __LINE__, psz)
#define __DCL_TRACE1(fmt, arg1) \
    DCLDebugTrace(__THIS_FILE__, __LINE__, fmt, arg1)
#define __DCL_TRACE2(fmt, arg1, arg2) \
    DCLDebugTrace(__THIS_FILE__, __LINE__, fmt, arg1, arg2)
#define __DCL_TRACE3(fmt, arg1, arg2, arg3) \
    DCLDebugTrace(__THIS_FILE__, __LINE__, fmt, arg1, arg2, arg3)
#define __DCL_TRACE4(fmt, arg1, arg2, arg3, arg4) \
    DCLDebugTrace(__THIS_FILE__, __LINE__, fmt, arg1, arg2, arg3, arg4)
#define __DCL_TRACE5(fmt, arg1, arg2, arg3, arg4, arg5) \
    DCLDebugTrace(__THIS_FILE__, __LINE__, fmt, arg1, arg2, arg3, arg4, arg5)
#define __DCL_TRACE6(fmt, arg1, arg2, arg3, arg4, arg5, arg6) \
    DCLDebugTrace(__THIS_FILE__, __LINE__, fmt, arg1, arg2, arg3, arg4, arg5, arg6)
 
#else   /* __DCL_DEBUG */
 
#define __DCL_ASSERT(expr)          ((void)0)
#define __DCL_ASSERT_EX(expr, msg)  ((void)0)
#define __DCL_VERIFY(expr)          ((void)(expr))
 
#define __DCL_TRACE0(psz)
#define __DCL_TRACE1(fmt, arg1)
#define __DCL_TRACE2(fmt, arg1, arg2)
#define __DCL_TRACE3(fmt, arg1, arg2, arg3)
#define __DCL_TRACE4(fmt, arg1, arg2, arg3, arg4)
#define __DCL_TRACE5(fmt, arg1, arg2, arg3, arg4, arg5)
#define __DCL_TRACE6(fmt, arg1, arg2, arg3, arg4, arg5, arg6)
 
#endif  /* __DCL_DEBUG */
 
#define __DCL_ASSERT_HANDLE(expr)   __DCL_ASSERT(expr)
#define __DCL_ASSERT_PARAM(expr)    __DCL_ASSERT(expr)
 
#include <new>
 
#if __DCL_HAVE_ALLOC_DEBUG
 
typedef enum {
    DCL_ALLOC_DEFAULT = (short) 0,  /* malloc, calloc, reallc, free         */
    DCL_ALLOC_NEW,                  /* new char, new int, new struct, ...   */
    DCL_ALLOC_NEW_ARRAY,            /* new char[], new int[], ...           */
    DCL_ALLOC_NEW_OBJECT,           /* new Object                           */
    DCL_ALLOC_NEW_OBJECT_ARRAY,     /* new Object[]                         */
    DCL_ALLOC_DELETE,               /* delete ptr                           */
    DCL_ALLOC_DELETE_ARRAY,         /* delete[] ptr                         */
    DCL_ALLOC_DELETE_OBJECT,        /* delete (Object*)                     */
    DCL_ALLOC_DELETE_OBJECT_ARRAY   /* delete[] (Object*)                   */
} DCLAllocFunc;

DCLCAPI void DCLDebugAllocEnterNear(
    const char_t* _filename,
    unsigned int    _line
);
 
DCLCAPI void* DCLDebugMalloc(
    size_t          _size,
    bool            _check,
    DCLAllocFunc    _func,
    const char_t* _filename,
    unsigned int    _line
);
 
DCLCAPI void DCLDebugFree(
    void*           _ptr, 
    DCLAllocFunc    _func,
    const char_t* _filename,
    unsigned int    _line
);
 
DCLCAPI void* DCLDebugCalloc(
    size_t          _count,
    size_t          _size,
    bool            _check,
    const char_t* _filename,
    unsigned int    _line
);
 
DCLCAPI void* DCLDebugRealloc(
    void*           _ptr, 
    size_t          _size,
    bool            _check,
    const char_t* _filename,
    unsigned int    _line
);
 
DCLCAPI bool DCLDebugAllocIsValid(
    const void*     _ptr
);
 
DCLCAPI void DCLDebugAllocSetCheckFlag(
    const void*     _ptr,
    bool            _check
);

DCLCAPI bool DCLDebugAllocGetPosition(
    const void*     _ptr,
    char_t*           _filename,
    size_t          _buflen,
    unsigned int*   _line
);

DCLCAPI const void* DCLDebugGetLastAllocPosition(
    thread_t _threadId
);
 
typedef enum {
    DCL_ALLOC_DUMP_ALL  = 0,
    DCL_ALLOC_DUMP_INTERNAL,
    DCL_ALLOC_DUMP_USER
} DCLAllocLeakDumpLevel;
 
/* 
uThreadId가 할당한 _startPosition에서 최근까지의 메모리 누출 보고
return : 성공하면 메모리 누출 항목의 갯수 >= 0, 실패(-1) 출력을 위한 버퍼할당 오류
*/
DCLCAPI size_t DCLDebugDumpThreadMemoryLeak(
    thread_t _threadId,
    const void* _startPosition,
    DCLAllocLeakDumpLevel _level,
    __DCL_NAMESPACE Writer* _writer
);
 
/*
프로세스가 할당한 전체 메모리 누출 보고
return : 성공하면 메모리 누출 항목의 갯수 >= 0, 실패(-1) 출력을 위한 버퍼할당 오류
*/
DCLCAPI size_t DCLDebugDumpGlobalMemoryLeak(
    DCLAllocLeakDumpLevel _level,
    __DCL_NAMESPACE Writer* _writer
);
 
/*****************************************************
    NEW/DELETE FOR ALLOC DEBUG
*****************************************************/
 
// Global new/delete Operator Overload
DCLCAPI void* operator new(
    size_t              _size,
    bool                _check,
    const char_t*     _filename,
    unsigned int        _line
);
 
DCLCAPI void* operator new[](
    size_t              _size,
    bool                _check,
    const char_t*     _filename,
    unsigned int        _line
);
 
DCLCAPI void operator delete(
    void*               _ptr, 
    bool                _check,
    const char_t*     _filename, 
    unsigned int        _line
) noexcept;
 
DCLCAPI void operator delete[](
    void*               _ptr,
    bool                _check,
    const char_t*     _filename,
    unsigned int        _line
) noexcept;
 
#define __DCL_TRACE_INTNAL_     0
 
#ifdef __WINNT__
 
#if __DCL_TRACE_INTNAL_
    #include <stdio.h>
    #define __DCL_TRACE_INTNAL_DELETE_FN__ \
        fprintf(stderr, "%s:%d __delete__ %p\n", __FILE__, __LINE__, _ptr);
    #define __DCL_TRACE_INTNAL_NEW_A__ \
        fprintf(stderr, "%s:%d new[] %zd %p\n", __FILE__, __LINE__, _size, r);
    #define __DCL_TRACE_INTNAL_DELETE_A__ \
        fprintf(stderr, "%s:%d delete[] %p\n", __FILE__, __LINE__, _ptr);
    #define __DCL_TRACE_INTNAL_NEW__ \
        fprintf(stderr, "%s:%d new %zd %p\n", __FILE__, __LINE__, _size, r);
    #define __DCL_TRACE_INTNAL_DELETE__ \
        fprintf(stderr, "%s:%d delete %p\n", __FILE__, __LINE__, _ptr);
#else
    #define __DCL_TRACE_INTNAL_DELETE_FN__
    #define __DCL_TRACE_INTNAL_NEW_A__
    #define __DCL_TRACE_INTNAL_DELETE_A__
    #define __DCL_TRACE_INTNAL_NEW__
    #define __DCL_TRACE_INTNAL_DELETE__
#endif
    // MSC에서 다음 4개의 new, delete는 dllexport, dllimport 할 수 없다.
    #ifdef __WINNT_GCC__
    // MinGW g++에서는 overrided delete가 호출되지 않는다.
    template<typename TYPE>
    void __delete__(TYPE* _ptr, const char_t* _filename, unsigned int _line) {
        _ptr->~TYPE();
        __DCL_TRACE_INTNAL_DELETE_FN__
        DCLDebugFree(_ptr, DCL_ALLOC_DELETE, _filename, _line);
    }
 
    void* operator new[](size_t _size);
    void operator delete[](void* _ptr) noexcept;
 
    #define __WINNT_NEW_DELETE_OVERRIDE \
    void* operator new[](size_t _size)\
    {\
        void* r = DCLDebugMalloc(\
            _size == 0 ? 1 : _size, true, DCL_ALLOC_NEW_ARRAY, NULL, 0\
        );\
        __DCL_TRACE_INTNAL_NEW_A__\
        return r;\
    }\
    void operator delete[](void* _ptr) noexcept\
    {\
        __DCL_TRACE_INTNAL_DELETE_A__\
        DCLDebugFree(_ptr, DCL_ALLOC_DELETE_ARRAY, NULL, 0);\
    }
    #else   // __WINNT_GCC__
    void* operator new(size_t _size);
    void operator delete(void* _ptr) noexcept;
    void* operator new[](size_t _size);
    void operator delete[](void* _ptr) noexcept;
 
    #define __WINNT_NEW_DELETE_OVERRIDE\
    void* operator new(size_t _size)\
    {\
        void* r = DCLDebugMalloc(\
            _size == 0 ? 1 : _size, true, DCL_ALLOC_NEW, NULL, 0\
        );\
        __DCL_TRACE_INTNAL_NEW__\
        return r;\
    }\
    void operator delete(void* _ptr) noexcept\
    {\
        __DCL_TRACE_INTNAL_DELETE__\
        DCLDebugFree(_ptr, DCL_ALLOC_DELETE, NULL, 0);\
    }\
    void* operator new[](size_t _size)\
    {\
        void* r = DCLDebugMalloc(\
            _size == 0 ? 1 : _size, true, DCL_ALLOC_NEW_ARRAY, NULL, 0\
        );\
        __DCL_TRACE_INTNAL_NEW_A__\
        return r;\
    }\
    void operator delete[](void* _ptr) noexcept\
    {\
        __DCL_TRACE_INTNAL_DELETE_A__\
        DCLDebugFree(_ptr, DCL_ALLOC_DELETE_ARRAY, NULL, 0);\
    }
    #endif  // __WINNT_GCC__
#else   // __WINNT__
    // MinGW clang++ 및 UNIX g++, clang++에서 DSO 구현이 사용가능하다.
    // GCC에서 delete를 inline으로 하면 컴파일러가 제공하는 delete가 호출된다.
    DCLCAPI void* operator new(size_t _size);
    DCLCAPI void* operator new[](size_t _size);
    DCLCAPI void operator delete(void* _ptr) noexcept;
    DCLCAPI void operator delete[](void* _ptr) noexcept;
#endif
 
// for default placement
//#if __GNUC__ >=3 || _MSC_VER >= 1200
/*
inline void* operator new(size_t, void* _ptr){  return _ptr; }
inline void* operator new[](size_t, void* _ptr) { return _ptr; }
inline void operator delete(void*, void*) { }
inline void operator delete[](void*, void*) { }
*/
//#else
//#include <new>
//#endif
 
//#else /* __DCL_HAVE_ALLOC_DEBUG */
//#include <new>
 
#endif      /* __DCL_HAVE_ALLOC_DEBUG */
 
/*****************************************************
    MACRO FOR ALLOC DEBUG
*****************************************************/
 
#if __DCL_HAVE_ALLOC_DEBUG
 
#define __DCL_ALLOC_INTERNAL    false
#define __DCL_ALLOC_USER        true
#define __DCL_ALLOC_LEVEL       __DCL_ALLOC_USER
 
#define __DCL_DEBUG_NEW \
            new(__DCL_ALLOC_LEVEL, __THIS_FILE__, __LINE__)
#define __DCL_DEBUG_MALLOC(size)    \
            DCLDebugMalloc(size, __DCL_ALLOC_LEVEL, DCL_ALLOC_DEFAULT, __THIS_FILE__, __LINE__)
#define __DCL_DEBUG_CALLOC(count, size) \
            DCLDebugCalloc(count, size, __DCL_ALLOC_LEVEL, __THIS_FILE__, __LINE__)
#define __DCL_DEBUG_REALLOC(ptr, size) \
            DCLDebugRealloc(ptr, size, __DCL_ALLOC_LEVEL, __THIS_FILE__, __LINE__)
#define __DCL_DEBUG_FREE(ptr) \
            DCLDebugFree(ptr, DCL_ALLOC_DEFAULT, __THIS_FILE__, __LINE__)
 
#ifdef __WINNT_GCC__
    #define __DCL_DEBUG_DELETE(_p) __delete__(_p, __THIS_FILE__, __LINE__)
    // #define delete(_p) __DCL_DEBUG_DELETE(_p)
#endif
 
#define new __DCL_DEBUG_NEW
#define malloc(size)            __DCL_DEBUG_MALLOC(size)
#define calloc(count, size)     __DCL_DEBUG_CALLOC(count, size)
#define realloc(ptr, size)      __DCL_DEBUG_REALLOC(ptr, size)
#define free(ptr)               __DCL_DEBUG_FREE(ptr)
 
/* macro disable
#undef new
#undef malloc
#undef calloc
#undef realloc
#undef free
*/
 
#endif  // __DCL_HAVE_ALLOC_DEBUG
 
#ifdef __DCL_HAVE_ALLOC_DEBUG
#define __DCL_DEBUG_ALLOC_ENTER     DCLDebugAllocEnterNear(__THIS_FILE__, __LINE__)
#define __DCL_DEBUG_ALLOC_LEAVE     DCLDebugAllocEnterNear(NULL, 0)
#else
#define __DCL_DEBUG_ALLOC_ENTER
#define __DCL_DEBUG_ALLOC_LEAVE
#endif
 
#if 0
#undef __THIS_FILE__
#define __THIS_FILE__   __T(__FILE__)
#endif
 
#endif  // __DCL_OBJECT_H__