Object.cpp

Go to the documentation of this file.

#include <dcl/Config.h>
 
#if __DCL_WINDOWS
#include <windows.h>        // for dcl/Thread.h
#endif
 
#ifdef __GNUC__
#include <cxxabi.h>
#endif
 
#include <dcl/Object.h>
#include <dcl/String.h>
#include <dcl/Charset.h>
#include <dcl/Thread.h>
#include <dcl/Writer.h>
 
#if __DCL_DEBUG
#undef __THIS_FILE__
static const char_t __THIS_FILE__[] = __T("dcl/Object.cpp");
#endif
 
__DCL_BEGIN_NAMESPACE
 
#ifdef __DCL_NO_RTTI
const Object::ClassInfo Object::m_classInfo = 
{
    __T(__DCL_NAMESPACE_STRING) __T("Object"), sizeof(Object), NULL
};
 
const Object::ClassInfo* Object::classInfo() const
{
    return CLASSINFO(Object);
}
 
String Object::className() const
{
    return String(classInfo()->pszClassName);
}
 
bool Object::isKindOf(const Object::ClassInfo* pClassInfo) const
{
    const ClassInfo* pChildInfo = classInfo();
    do
    {
        if (pChildInfo == pClassInfo)
            return true;
 
        pChildInfo = pChildInfo->pBaseClassInfo;
    } while (pChildInfo);
    
    return false;
}
 
bool Object::isInstanceOf(const Object::ClassInfo* pClassInfo) const
{
    return classInfo() == pClassInfo;
}
 
#else   // __DCL_NO_RTTI
 
/*
class Object
{
    ...
    virtual bool isKindOf(const std::type_info& typeInfo) const;
};
 
#ifdef __DCL_NO_RTTI
#define CLASSINFO_REF   const Object::ClassInfo*
#define CLASSINFO(class_name) (&class_name::m_classInfo)
#define DECLARE_CLASSINFO(class_name) \
public: \
    static const ClassInfo m_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 bool isKindOf(const std::type_info& typeInfo) const; \
    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::m_classInfo = \
{ \
    __DCL_NAMESPACE_STRING #class_name, \
    sizeof(class class_name), \
    &base_class_name::m_classInfo \
}; \
const Object::ClassInfo* class_name::classInfo() const \
{ \
    return CLASSINFO(class_name); \
}
#else
#define IMPLEMENT_CLASSINFO(class_name, base_class_name) \
bool class_name::isKindOf(const std::type_info& typeInfo) const \
{ \
    if (typeid(class_name) == typeInfo) \
        return true; \
    return base_class_name::isKindOf(typeInfo); \
} \
const std::type_info& class_name::typeInfo() const \
{ \
    return typeid(class_name); \
}
 
bool class_name::isKindOf(const std::type_info& typeInfo) const \
{ \
    if (typeid(class_name) == typeInfo) \
        return true; \
    return base_class_name::isKindOf(typeInfo); \
} \
 
bool Object::isKindOf(const std::type_info& info) const
{
#if _MSC_VER <= 1200
    return (typeid(Object) == info) != 0;
#else
    return typeid(Object) == info;
#endif
}
*/
 
const std::type_info& Object::typeInfo() const
{
//  return typeid(*this);
    return typeid(Object);
}
 
static String __getDemangledTypeName(const std::type_info& info)
{
    const char* demangled = NULL;
 
#ifdef _MSC_VER
    // MSC "class foo::a"
    const char* _p = strchr(info.name(), ' ');
    if (_p) {
        while(*_p == ' ') _p++;
        demangled = _p;
    }
    else
        demangled = info.name();
 
#elif defined(__GNUC__)
    // GNUC mangled
    char buf[1024];
    size_t n = __countof(buf, char);
    int status = 0;
    demangled = __cxxabiv1::__cxa_demangle(info.name(), buf, &n, &status);
#endif
 
    String r;
    if (demangled) {
        // demangled is NULL terminated
        r = AsciiDecoder::decode(demangled);
    }
 
    return r;
}
 
String Object::className() const
{
    return __getDemangledTypeName(typeInfo());
}
 
bool Object::isInstanceOf(const std::type_info& info) const
{
#if _MSC_VER <= 1200
    return (typeInfo() == info) != 0;
#else   // __GNUC__, 
    return (typeInfo() == info);
#endif
}
 
#endif  // __DCL_NO_RTTI
 
Object::~Object()
{
}
 
Object::Object()
{
}
 
String Object::toString() const
{
    return className();
}
 
void Object::destroy()
{
    delete this;
}
 
#if __DCL_DEBUG
void Object::dump(Writer& out) const
{
    out << L"\n==========================\n"
        << className()
        << L"\n--------------------------\n";
}
#endif
 
#if __DCL_HAVE_ALLOC_DEBUG
#undef new
 
void* Object::operator new(
                size_t          _size,
                bool            _check,
                const char_t* _filename,
                unsigned int    _line
                )
{
    if (_size == 0)
        _size = 1;
    
    return DCLDebugMalloc(
                _size,
                _check,
                DCL_ALLOC_NEW_OBJECT,
                _filename,
                _line
                );
}   
 
void* Object::operator new[](
                size_t          _size,
                bool            _check,
                const char_t* _filename,
                unsigned int    _line
                )
{
    if (_size == 0)
        _size = 1;
    
    return DCLDebugMalloc(
                _size,
                _check,
                DCL_ALLOC_NEW_OBJECT_ARRAY,
                _filename,
                _line
                );
}
 
void Object::operator delete(
                void*           _p,
                bool,           // _check
                const char_t* _filename,
                unsigned int    _line
                )
{
    DCLDebugFree(
        _p, 
        DCL_ALLOC_DELETE_OBJECT,
        _filename,
        _line
        );
}
 
void Object::operator delete[](
                void*           _p,
                bool,           // _check
                const char_t* _filename,
                unsigned int    _line
                )
{
    DCLDebugFree(
        _p,
        DCL_ALLOC_DELETE_OBJECT_ARRAY,
        _filename,
        _line
        );
}
 
 
void* Object::operator new(size_t)
{
    __DCL_ASSERT_EX(false, L"디버그 버전으로 빌드된 라이브러리에서 호출될 수 없습니다.!");
    return (void*)0;    // GCC에서 new는 NULL을 리턴하지 않고 예외를 발생시킨다.
}
 
void* Object::operator new[](size_t)
{
    __DCL_ASSERT_EX(false, L"디버그 버전으로 빌드된 라이브러리에서 호출될 수 없습니다.!");
    return (void*)0;
}
 
 
void Object::operator delete(void* _p)
{
    Object::operator delete(_p, true, NULL, 0);
}
 
void Object::operator delete[](void* _p)
{
    Object::operator delete[](_p, true, NULL, 0);
}
 
#endif  // __DCL_HAVE_ALLOC_DEBUG
 
__DCL_END_NAMESPACE