base_unique_ptr.hh

Go to the documentation of this file.

/*
 * LEGAL:   COPYRIGHT (C) JIM E. BROOKS 2007
 *          THIS SOURCE CODE IS RELEASED UNDER THE TERMS
 *          OF THE GNU GENERAL PUBLIC LICENSE VERSION 2 (GPL 2).
 *****************************************************************************/


#ifndef BASE_UNIQUE_PTR_HH
#define BASE_UNIQUE_PTR_HH 1



#include "base_common.hh"
#include "base_defs.hh"
#include "base_funcs.hh"

namespace base {

// Applying a global lock to every type of UniqueFactory isn't optimal,
// but a single lock allows the UniqueFactory class to contain and hide it.
#if COMPILE_THREADS
namespace restrict { BASE_GLOBAL FastLock gLockUniqueFactory; }
#endif

#define uniptr UniquePtr

class Unique
{
    // Empty base class.
    //
    // Don't try to optimize UniqueFactory by letting it store a flag in this class
    // in order to reduce searching STL set.  The problem is that clients would be ignorant
    // of such a flag and may change the same object and encapsulate it in multiple UniquePtrs
    // (an example is Import) but flag would incorrectly be true after every modification.
public:
    ;
};

template<typename T>
class UniqueFactory : private Threadable
{
public:
    UniqueFactory( void ) { SET_TYPESIG(this,TYPESIG_UNIQUE_FACTORY); }
    ~UniqueFactory()      { INVALIDATE_TYPESIG(this,TYPESIG_UNIQUE_FACTORY); }

    // Substitute a new object with an equal object from the unique set.
    SafePtr<const T> Substitute( const T* obj )
    {
    THREAD_CODE( FastLock::Auto autolock( &restrict::gLockUniqueFactory ); )
    CHECK_TYPESIG(this,TYPESIG_UNIQUE_FACTORY);  // catch if factory was destroyed

        if ( EX( obj != NULL ) )
        {
            // Compiler's type-checking prevents a caller passing back
            // what this returns (SafePtr<T> can't be passed as T*).
            // If not for SafePtr, "delete obj" could corrupt the set.
            SafePtr<const T> obj2 = Substitute( *obj );
            delete obj;  // client is supposed to let UniqueFactory own it
            return obj2;
        }
        else
        {
            return NULL;  // toss grenade back
        }
    }

    // Substitute a reference with an equal object in the unique set.
    SafePtr<const T> Substitute( const T& obj )
    {
    THREAD_CODE( FastLock::Auto autolock( &restrict::gLockUniqueFactory ); )
    CHECK_TYPESIG(this,TYPESIG_UNIQUE_FACTORY);

        // insert() either inserts a new item or returns an existing one.
        // Pointers to STL set elements are ok.
        pair<typename set<T>::iterator,bool> iter_flag = mSet.insert( obj );
        const T* unique = &*iter_flag.first;  // &* is an STL idiom
        CHECK_TYPESIG( unique, TYPESIG_UNIQUE );  // catch if client misuses PTR() and deletes it
        return unique;
    }

#if DEBUG || STATS
    uint GetCnt( void ) const { return mSet.size(); }  // number of items in factory
#endif

private:
    set<T>  mSet;  // STL set provides uniqueification.  BTW, "set<const T>" doesn't compile.
public:
    
};

// Smart pointer that shares a unique object.
//
template<typename T>
class UniquePtr : private Threadable
{

public:
    // For pointer variants, UniquePtr takes ownership of given object (like SharedPtr).
    UniquePtr( const T* obj ) : mObj(T::GetUniqueFactory().Substitute(obj)) { }
    UniquePtr( const T& obj ) : mObj(T::GetUniqueFactory().Substitute(obj)) { }
  //UniquePtr( UniquePtr& ); // default suffices
    ~UniquePtr() { }  // mObj owned by factory
    const UniquePtr& operator=( const T* obj ) { mObj = T::GetUniqueFactory().Substitute( obj ); }
    const UniquePtr& operator=( const T& obj ) { mObj = T::GetUniqueFactory().Substitute( obj ); }
  //operator=(UniquePtr&) // default suffices
    const T* operator->( void ) const { return mObj.CONST_PTR(); }  // returns const to prevent client turning it into a duplicate
    const T& operator*( void ) const { return mObj.CONST_REF(); }  // limited use (extracted reference could dangle)
    bool operator==( const UniquePtr& other ) const { return mObj == other.mObj; }
    bool operator!=( const UniquePtr& other ) const { return mObj != other.mObj; }
    bool operator==( const T* obj ) const { return mObj == obj; }
    bool operator!=( const T* obj ) const { return mObj != obj; }
    bool operator==( const T& obj ) const { return *mObj == obj; }
    bool operator!=( const T& obj ) const { return *mObj != obj; }
    // Very limited use.  Avoiding the risk of deleting object owned by UniqueFactory!
    const T* CONST_PTR( void ) const { return mObj; }
    const T& CONST_REF( void ) const { return *mObj; }

private:
    SafePtr<const T>  mObj;  // factory owns it
};

template<typename T> bool operator==( const UniquePtr<T>& a, const UniquePtr<T>& b ) { return a.PTR() == b.PTR(); }
template<typename T> bool operator!=( const UniquePtr<T>& a, const UniquePtr<T>& b ) { return a.PTR() != b.PTR(); }
template<typename T> bool operator<( const UniquePtr<T>& a, const UniquePtr<T>& b ) { return a.PTR() < b.PTR(); }

} // namespace base

#endif // BASE_UNIQUE_PTR_HH

Palomino 3D Engine documents generated by doxygen 1.5.3 on Fri Nov 23 11:26:07 2007