object.hpp

Go to the documentation of this file.

#ifndef __LOGOG_OBJECT_HPP__
#define __LOGOG_OBJECT_HPP__

namespace logog
{

#ifdef LOGOG_LEAK_DETECTION

typedef void *PointerType;

typedef LOGOG_UNORDERED_MAP< PointerType, size_t > AllocationsType;

extern AllocationsType s_Allocations;

extern void LockAllocationsMutex();

extern void UnlockAllocationsMutex();
#endif // LOGOG_LEAK_DETECTION

#ifdef new
#define LOGOG_PREVIOUS_DEFINITION_OF_NEW new
#undef new
#endif
#ifdef delete
#define LOGOG_PREVIOUS_DEFINITION_OF_DELETE delete
#undef delete
#endif  //delete

class Object
{
public:
    Object();
        /* Some builds complain about ~Object() being virtual... sorry lint :( */
    virtual ~Object();
    void *operator new( size_t nSize );
    void *operator new[](size_t nSize);

        /* There's a wonderful behavior in Windows MFC in debug builds that causes it 
         * to attempt to redefine NEW with a macro if we're compiling in debug mode
         * and we're using Gdiplus as well.  In that case, Windows attempts to redefine
         * new with a macro for everything that has a new.  This wonderful behavior 
         * is worked around here.  See http://support.microsoft.com/kb/317799/EN-US/
         * and http://social.msdn.microsoft.com/Forums/en/vcgeneral/thread/0df13145-670e-4070-b0a1-61794b20dff7
         * for more exciting information.
         */
#ifdef _DEBUG
#ifdef LOGOG_FLAVOR_WINDOWS
        void* operator new(size_t nSize, LPCSTR lpszFileName, int nLine);
        void* operator new[](size_t nSize, LPCSTR lpszFileName, int nLine);
        void  operator delete(void* ptr, LPCSTR lpszFileName, int nLine);
        void  operator delete[](void* ptr, LPCSTR lpszFileName, int nLine);
#endif // LOGOG_FLAVOR_WINDOWS
#endif // _DEBUG

    void operator delete( void *ptr );
    void operator delete[]( void *ptr );

    static void *Allocate( size_t nSize );

    static void Deallocate( void *ptr );
 };

#ifdef LOGOG_PREVIOUS_DEFINITION_OF_NEW
#define new LOGOG_PREVIOUS_DEFINITION_OF_NEW
#endif 

#ifdef LOGOG_PREVIOUS_DEFINITION_OF_DELETE
#define delete GA_PREVIOUS_DEFINITION_OF_DELETE
#endif

template <class T>
class Allocator
{
public:
    typedef size_t    size_type;
    typedef ptrdiff_t difference_type;
    typedef T        *pointer;
    typedef const T  *const_pointer;
    typedef T        &reference;
    typedef const T  &const_reference;
    typedef T         value_type;

    Allocator() {}
    Allocator( const Allocator & ) {}

    pointer   allocate( size_type n, const void * = 0 )
    {
        T *t = ( T * ) Object::Allocate( n * sizeof( value_type ) );
        return t;
    }

    void      deallocate( void *p, size_type )
    {
        if ( p )
        {
            Object::Deallocate( p );
        }
    }

    pointer           address( reference x ) const
    {
        return &x;
    }
    const_pointer     address( const_reference x ) const
    {
        return &x;
    }
    Allocator<T>&  operator=( const Allocator & )
    {
        return *this;
    }
    void              construct( pointer p, const T &val )
    {
        new(( T * ) p ) T( val );
    }
    void              destroy( pointer p )
    {
#ifdef LOGOG_FLAVOR_WINDOWS
        // MSVC tends to complain unless we reference this pointer here.
        p;
#endif // LOGOG_FLAVOR_WINDOWS
        p->~T();
    }

    size_type         max_size() const
    {
        return size_t( -1 );
    }

    template <class U>
    struct rebind
    {
        typedef Allocator<U> other;
    };

    template <class U>
    Allocator( const Allocator<U>& ) {}

    template <class U>
    Allocator &operator=( const Allocator<U>& )
    {
        return *this;
    }
};

/* All specializations of this allocator are interchangeable. */
template <class T1, class T2>
bool operator== ( const Allocator<T1>&,
                  const Allocator<T2>& )
{
    return true;
}
template <class T1, class T2>
bool operator!= ( const Allocator <T1>&,
                  const Allocator<T2>& )
{
    return false;
}

//

extern int MemoryAllocations();

extern int ReportMemoryAllocations();

}
#endif // __LOGOG_OBJECT_HPP