examples/Basics/CClasses/CClasses.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"

// start of real example

// #include specific files

// class with single-phase construction, NewL and NewLC

class COnePhaser : public CBase {
public: // data
        TInt iInt1; // one integer
        TInt iInt2; // another integer
public: // functions
        // construct/destruct
        static COnePhaser* NewL()
                { // construct and leave if error
                return new (ELeave) COnePhaser; // new COnePhaser, C++ constructor
                };
        static COnePhaser* NewLC()
                { // construct, leave if error, else push to clean-up stack
                COnePhaser* self=COnePhaser::NewL(); // construct
                CleanupStack::PushL(self); // push to clean-up stack
                return self; // and return new object
                };
        // other functions
        void Print()
                {
                _LIT(KFormat1,"COnePhaser {TInt %d, TInt %d}");
                console->Printf(KFormat1, iInt1, iInt2);
                }
protected: // functions
        // construct
        COnePhaser()
                { // standard C++ constructor, because it cannot leave
                iInt1=3; // set first int to 3
                // iInt2=0; // unnecessary
                }
        };

// class with two-phase construction

class CTwoPhaser : public CBase {
public: // data
        TInt iInt1; // one integer
        TInt iInt2; // another integer
        RTimer iTimer; // a resource
        COnePhaser* iOnePhaser; // another CBase object
public: // functions
        // construct/destruct
        static CTwoPhaser* NewLC(TInt aInt1)
                { // construct and leave on the clean-up stack
                CTwoPhaser* self=new (ELeave) CTwoPhaser; // new CTwoPhaser, initialized to binary zeroes
                CleanupStack::PushL(self); // push to clean-up stack
                self->ConstructL(aInt1); // construct
                return self; // return new object
                };
        static CTwoPhaser* NewL(TInt aInt1)
                { // construct and don't leave on clean-up stack
                CTwoPhaser* self=CTwoPhaser::NewLC(aInt1); // construct and leave on clean-up stack
                CleanupStack::Pop(); // pop from clean-up stack
                return self; // return new object
                };
        virtual ~CTwoPhaser()
                {
                delete iOnePhaser; // just destroy anything we point to
                iTimer.Close(); // close timer
                }
        // other functions
        void Print()
                {
                _LIT(KFormat2,"CTwoPhaser {TInt %d, TInt %d, RTimer, ");
                console->Printf(KFormat2, iInt1, iInt2);
                iOnePhaser->Print();
                _LIT(KtxtCloseCurly,"}");
                console->Printf(KtxtCloseCurly);
                }
protected: // functions
        // construct support
        void ConstructL(TInt aInt1)
                { // do the work involved in construction
                iInt1=aInt1; // assign iInt1 from argument
                User::LeaveIfError(iTimer.CreateLocal()); // initialize timer
                iOnePhaser=COnePhaser::NewL(); // make a new one-phaser
                }
        };

// abstract class derived from CBase

class CAbstract : public CBase
        {
public: // data
        CTwoPhaser* iTwoPhaser; // a contained object
public: // functions
        void SomeFunction(TInt aInt)
                { // request some function
                _LIT(KTxtbeginSomeFunction,"beginning to do SomeFunction()\n");
                console->Printf(KTxtbeginSomeFunction);
                DoSomeFunction(aInt); // invoke virtual function
                _LIT(KTxtfinishSomeFunction,"finished doing SomeFunction()\n");
                console->Printf(KTxtfinishSomeFunction);
                }
        virtual ~CAbstract()
                {
                delete iTwoPhaser;
                }
protected:
        virtual void DoSomeFunction(TInt aInt) const =0;
                // implement heart of some function, in derived class
        void ConstructL(TInt aInt)
                { // second phase of constructor
                iTwoPhaser=CTwoPhaser::NewL(aInt);
                        // construct embedded object
                }
        };

// class derived from above

class CConcrete : public CAbstract
        {
public: // data
        COnePhaser* iOnePhaser; // some extra data
public: // functions
        // construct/destruct
        static CConcrete* NewLC(TInt aInt)
                { // construct and leave on the clean-up stack
                CConcrete* self=new (ELeave) CConcrete; // new object, C++ constructor
                CleanupStack::PushL(self); // push to clean-up stack
                self->ConstructL(aInt); // CBase constructor
                return self; // return new object
                };
        static CConcrete* NewL(TInt aInt)
                { // construct and don't leave on clean-up stack
                CConcrete* self=CConcrete::NewLC(aInt); // construct and leave on clean-up stack
                CleanupStack::Pop(); // pop from clean-up stack
                return self; // return new object
                };
        virtual ~CConcrete()
                {
                delete iOnePhaser; // destroy member
                }
        // protocol
        virtual void DoSomeFunction(TInt aInt) const
                { // implementation of base class's pure-virtual function
                _LIT(KFormat3,"CConcrete::DoSomething(%d)\n");
                console->Printf(KFormat3, aInt);
                }
protected:
        // construct/destruct
        void ConstructL(TInt aInt)
                { // second phase of construction
                CAbstract::ConstructL(aInt); // base class constructor
                iOnePhaser=COnePhaser::NewL(); // contained member constructor
                }
        };

// do the example
LOCAL_C void doExampleL()
    {
        // two-phase object
        CTwoPhaser* twoPhaser=CTwoPhaser::NewLC(5);
                        // new two-phase object
        twoPhaser->Print(); // print it
        _LIT(KTxtNewLine,"\n");
        console->Printf(KTxtNewLine);  // with trailing new-line
        CleanupStack::PopAndDestroy(); // two-phase object
        // concrete instance of an abstract class
        CAbstract* abstract=CConcrete::NewLC(9);
                // new concrete object, but refer to it with abstract pointer
        abstract->SomeFunction(11); // do something with it
        CleanupStack::PopAndDestroy(); // abstract object
        }

---