/*
* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:
*
*/

#ifndef JCFAUTOPTR_H
#define JCFAUTOPTR_H

#include <e32base.h>

/**
 * Functionality of this auto ptr class is same as stl's auto_ptr class
 * except this works with cleanup stack.
 * Implementation of the example operation with "traditional" way:
 * void bar()
 *   {
 *   CFoo* myFoo = CFoo::NewL();
 *   CleanupStack::PushL(myFoo);
 *   myFoo->DoSomeThingL();
 *   CleanupStack::PopAndDestroy(1); //myFoo
 *   }
 * Implementation of the same function with auto pointer class:
 * void bar()
 *   {
 *   jcfcommon::auto_ptr<CFoo> myFoo(CFoo::NewL());
 *   myFoo->DoSomeThingL();
 *   }
 *
 */
namespace jcfcommon
{

template<class X> class auto_ptr
{
public:
    typedef X element_type;

    auto_ptr(X* aPtr = 0): iPtr(aPtr),iCloseCalledFlag(EFalse)
    {
        CleanupStack::PushL(TCleanupItem(Close, (void*)this));
    }

    /**
     * Copy constructor was commented out because current
     * implementation doesn't support situation where auto_ptr
     * is returned as return value of the function. Problem is that
     * orig. auto_ptr is deleted when getBar() operation has been
     * executed and this deleted local reference has been stored to the
     * cleanup stack.
     * E.g:
     * void foo()
     *   {
     *   auto_ptr<bar> barObj = getBar();
     *       .
     *       .
     *       .
     *   User::Leave(KErrNotFound);
     *   }
     */
    /*auto_ptr(auto_ptr& aPtr): iPtr(aPtr.release())
    {
      CleanupStack::PushL(TCleanupItem(Close, (void*)this));
    }*/

    auto_ptr<X>& operator=(auto_ptr<X>& aRhs)
    {
        if (&aRhs != this)
        {
            delete iPtr;
            iPtr = aRhs.release();
        }
        return (*this);
    }

    ~auto_ptr()
    {
        if (!iCloseCalledFlag)
        {
            CleanupStack::Pop();
            delete iPtr;
        }
    }

    X& operator *() const
    {
        return *iPtr;
    }
    X* operator ->() const
    {
        return iPtr;
    }

    X* get() const
    {
        return iPtr;
    }

    X* release()
    {
        X* result = iPtr;
        iPtr = 0;
        return result;
    }

    void reset(X* aPtr = 0)
    {
        if (aPtr != iPtr)
        {
            delete iPtr;
            iPtr = aPtr;
        }
    }

private:
    static void Close(void* aPtr)
    {
        auto_ptr<X>* self = (auto_ptr<X>*)aPtr;
        delete self->iPtr;
        self->iPtr = 0;
        self->iCloseCalledFlag = ETrue;
    }

    //Not implemented.
    auto_ptr(auto_ptr& aPtr);

private:
    X* iPtr;
    TBool iCloseCalledFlag;
};

}//end jcfcommon

#endif // JCFAUTOPTR_H