examples/Base/MemMan/Cleanup/Utilities/Utilities.cpp

/*
Copyright (c) 2000-2010 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

* Redistributions of source code must retain the above copyright notice, this
  list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
  this list of conditions and the following disclaimer in the documentation
  and/or other materials provided with the distribution.
* Neither the name of Nokia Corporation nor the names of its contributors
  may be used to endorse or promote products derived from this software
  without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

Description:  
*/


#include "CommonFramework.h"

//
// Definition of the CTestOne class
//
class CTestOne : public CBase
        {       
public:
        ~CTestOne();
        void     SetTextL(const TDesC& aData);
private :
        HBufC*   iText;
        };


//
// Implementation of the CTestOne class
//
_LIT(KTxtInsideDestructor,"Executing the CTestOne destructor\n");
CTestOne::~CTestOne()
        {
        delete iText;
        console->Printf(KTxtInsideDestructor);
        }

void CTestOne::SetTextL(const TDesC& aData)
        {
        if (iText)
                {
                delete iText;
                iText = NULL;
                }
        iText = aData.AllocL(); 
        }



//
// Definition of the RTestTwo class
//
class RTestTwo
        {       
public:
        RTestTwo(TInt aValue);
        void     Close();
private :
        TInt     iX;
        };

//
// Implementation of the RTestTwo class
//
RTestTwo::RTestTwo(TInt aValue)
        : iX(aValue)
        {
        }


_LIT(KTxtCloseRTestTwo,"RTestTwo closing\n");

void RTestTwo::Close()
        {
        console->Printf(KTxtCloseRTestTwo);
        }



//
// Definition of the RTestThree class
//
class RTestThree
        {       
public:
        RTestThree(TInt aValue);
        void     Release();
private :
        TInt     iY;
        };

//
// Implementation of the RTestThree class
//
RTestThree::RTestThree(TInt aValue)
        : iY(aValue)
        {
        }


_LIT(KTxtReleaseRTestThree,"RTestThree releasing\n");

void RTestThree::Release()
        {
        console->Printf(KTxtReleaseRTestThree);
        }

//
// main body of the example
//
_LIT(KTxtHelloWorld,"Hello World!");
LOCAL_C void doExampleL()
    {
                // 1. Construct a CTestOne object on the heap
        CTestOne* one = new (ELeave) CTestOne;
        
                // Use the CleanupDeletePushL() function to put a TCleanUpItem
                // on the cleanup stack
        CleanupDeletePushL(one);

                // Exercise the CTestOne object (just to show it doing something)
        one->SetTextL(KTxtHelloWorld);

                // Pop and destroy the cleanup item off the cleanup stack.
                // The cleanup operation deletes the CTestOne object
        CleanupStack::PopAndDestroy();
        
                // 2. Construct a RTestTwo object on the program stack.
                //
                // The value passed is of no significance; it is just
                // to show that the class is not trivial.
        RTestTwo  two(2);
                
                // Use the CleanupClosePushL() function to put a TCleanUpItem
                // on the cleanup stack
        CleanupClosePushL(two);

                // Pop and destroy the cleanup item off the cleanup stack.
                // The cleanup operation calls the Close() member function of
                // the RTestTwo object
        CleanupStack::PopAndDestroy();
                                

                // 3. Construct a RTestThree object on the program stack.
                //
                // The value passed is of no significance; it is just
                // to show that the class is not trivial.
        RTestThree  three(3);
                
                // Use the CleanupClosePushL() function to put a TCleanUpItem
                // on the cleanup stack
        CleanupReleasePushL(three);

                // Pop and destroy the cleanup item off the cleanup stack.
                // The cleanup operation calls the Release() member function of
                // the RTestThree object
        CleanupStack::PopAndDestroy();

                // 4. Construct an array of objects on the heap
        TInt heapSize1 = User::Heap().Count(); // take a count of the heap size now
        
        const TInt KNumObjects = 4;
        const TInt KStringLength = 10;
        TBuf<KStringLength>* four = new (ELeave) TBuf<KStringLength>[KNumObjects];
                // Use the CleanupArrayDeletePushL() function to put a TCleanUpItem
                // on the cleanup stack
        CleanupArrayDeletePushL(four);

                // Do something that might leave - a simple memory allocation
        TInt* mem = (TInt*)User::Alloc(100);
        delete mem;

                // Pop and destroy the cleanup item off the cleanup stack.
                // The cleanup operation deletes the CTestOne object
        CleanupStack::PopAndDestroy();
        if ( User::Heap().Count() == heapSize1 )
                {
                _LIT(KFourComplete,"Array deleted\n");
                console->Printf(KFourComplete);
                }
        }

---