autoptr.h

Go to the documentation of this file.

//**************************************************************************/
// Copyright (c) 1998-2006 Autodesk, Inc.
// All rights reserved.
// 
// These coded instructions, statements, and computer programs contain
// unpublished proprietary information written by Autodesk, Inc., and are
// protected by Federal copyright law. They may not be disclosed to third
// parties or copied or duplicated in any form, in whole or in part, without
// the prior written consent of Autodesk, Inc.
//**************************************************************************/
// DESCRIPTION: Automatic pointer supporting resource-acquisition is 
//    initialization technique.
// AUTHOR: Nicolas Desjardins
// DATE: 2006/03/20 
//***************************************************************************/

#pragma once

#ifndef NULL
#define NULL 0
#endif

namespace MaxSDK
{

template<typename OtherType> struct AutoPtrRef
{
    OtherType *mPtr;
    AutoPtrRef(OtherType *p)  : mPtr(p) {}      
};


template <typename Type> class SinglePointerDestructor
{
public:
    static void Delete(Type *ptr) 
    { 
        delete ptr; 
    }
};

template <typename Type, typename DestructorPolicy = SinglePointerDestructor<Type> >
class AutoPtr
{
private:
    void * operator new(size_t size);   
    
    void * operator new(size_t size, void * placement);
    
    Type *mPtr;

public:
    typedef Type element_type;

    typedef DestructorPolicy destructor;

    explicit AutoPtr(Type *p = NULL)  : mPtr(p) {}

    ~AutoPtr()  { DestructorPolicy::Delete(mPtr); }

    AutoPtr(AutoPtr &a)  : mPtr(a.Release()) {}

    template <typename OtherType> AutoPtr(AutoPtr<OtherType, DestructorPolicy> &a) : 
        mPtr(a.Release()) 
    {}

    AutoPtr& operator=(AutoPtr &a) 
    {
        if(Get() != a.Get())
        {
            DestructorPolicy::Delete(mPtr);
            mPtr = a.Release();
        }
        return *this;
    }

    template<typename OtherType> AutoPtr& operator=(AutoPtr<OtherType, DestructorPolicy> &a) 
    {
        if(Get() != a.Get())
        {
            DestructorPolicy::Delete(mPtr);
            mPtr = a.Release();
        }
        return *this;
    }

    Type& operator*() const  { return *mPtr; }

    Type* operator->() const  { return mPtr; }

    Type* Get() const { return mPtr; }

    Type* Release() 
    {
        Type *temp = mPtr;
        mPtr = NULL;
        return temp;
    }

    void Reset(Type *p = NULL) 
    {
        if(p != mPtr)
        {
            DestructorPolicy::Delete(mPtr);
            mPtr = p;
        }
    }

    bool IsNull() const  { return (NULL == mPtr); }

    AutoPtr(const AutoPtrRef<Type> &ref) : mPtr(ref.mPtr) {}

    template<typename OtherType> operator AutoPtrRef<OtherType>() 
    {
        return AutoPtrRef<OtherType>(this->Release());
    }

    template<typename OtherType> operator AutoPtr<OtherType, DestructorPolicy>() 
    {
        return AutoPtr<OtherType, DestructorPolicy>(this->Release());
    }
};

template <typename Type> class ArrayPointerDestructor
{
public:
    static void Delete(Type *ptr) 
    { 
        delete [] ptr; 
    }
};

template <typename Type> class ArrayAutoPtr : public AutoPtr<Type, ArrayPointerDestructor<Type> > 
{
public:
    explicit ArrayAutoPtr(Type *p = NULL) : 
        AutoPtr<Type, ArrayPointerDestructor<Type> >(p)
    { };

    ArrayAutoPtr(const AutoPtrRef<Type> &ref) :
        AutoPtr<Type, ArrayPointerDestructor<Type> >(ref.mPtr)
    { }

    template<typename OtherType> operator ArrayAutoPtr<OtherType>() 
    {
        return ArrayAutoPtr<OtherType>(this->Release());
    }

    Type& operator[](int index) const
    { 
        return Get()[index];
    }
};

class DeleteThisDestructor
{
public:
    template <typename Type> static void Delete(Type *ptr)
    { 
        if(NULL != ptr)
        {
            ptr->DeleteThis(); 
        }
    }
};


template <typename Type> class DeleteThisAutoPtr : public AutoPtr<Type, DeleteThisDestructor > 
{
public:
    explicit DeleteThisAutoPtr(Type *p = NULL) : 
        AutoPtr<Type, DeleteThisDestructor >(p)
    { };

    DeleteThisAutoPtr(const AutoPtrRef<Type> &ref) :
        AutoPtr<Type, DeleteThisDestructor >(ref.mPtr)
    { }
};

namespace Util
{

template<typename Type> class AutoPtr : public MaxSDK::AutoPtr<Type>
{
public:
    explicit AutoPtr(Type *p = NULL) : 
        MaxSDK::AutoPtr<Type>(p)
    { };

    AutoPtr(const AutoPtrRef<Type> &ref) :
        MaxSDK::AutoPtr<Type>(ref.mPtr)
    { }

    template<typename OtherType> operator AutoPtr<OtherType>() 
    {
        return AutoPtr<OtherType>(this->Release());
    }
};

}

}