TB10.1 Example Applications: examples/Basics/CClasses/CClasses.cpp Source File

00001 // Copyright (c) 2000-2009 Nokia Corporation and/or its subsidiary(-ies).
+00002 // All rights reserved.
+00003 // This component and the accompanying materials are made available
+00004 // under the terms of "Eclipse Public License v1.0"
+00005 // which accompanies this distribution, and is available
+00006 // at the URL "http://www.eclipse.org/legal/epl-v10.html".
+00007 //
+00008 // Initial Contributors:
+00009 // Nokia Corporation - initial contribution.
+00010 //
+00011 // Contributors:
+00012 //
+00013 // Description:
+00014 //
+00015 
+00016 #include "CommonFramework.h"
+00017 
+00018 // start of real example
+00019 
+00020 // #include specific files
+00021 
+00022 // class with single-phase construction, NewL and NewLC
+00023 
+00024 class COnePhaser : public CBase {
+00025 public: // data
+00026         TInt iInt1; // one integer
+00027         TInt iInt2; // another integer
+00028 public: // functions
+00029         // construct/destruct
+00030         static COnePhaser* NewL()
+00031                 { // construct and leave if error
+00032                 return new (ELeave) COnePhaser; // new COnePhaser, C++ constructor
+00033                 };
+00034         static COnePhaser* NewLC()
+00035                 { // construct, leave if error, else push to clean-up stack
+00036                 COnePhaser* self=COnePhaser::NewL(); // construct
+00037                 CleanupStack::PushL(self); // push to clean-up stack
+00038                 return self; // and return new object
+00039                 };
+00040         // other functions
+00041         void Print()
+00042                 {
+00043                 _LIT(KFormat1,"COnePhaser {TInt %d, TInt %d}");
+00044                 console->Printf(KFormat1, iInt1, iInt2);
+00045                 }
+00046 protected: // functions
+00047         // construct
+00048         COnePhaser()
+00049                 { // standard C++ constructor, because it cannot leave
+00050                 iInt1=3; // set first int to 3
+00051                 // iInt2=0; // unnecessary
+00052                 }
+00053         };
+00054 
+00055 // class with two-phase construction
+00056 
+00057 class CTwoPhaser : public CBase {
+00058 public: // data
+00059         TInt iInt1; // one integer
+00060         TInt iInt2; // another integer
+00061         RTimer iTimer; // a resource
+00062         COnePhaser* iOnePhaser; // another CBase object
+00063 public: // functions
+00064         // construct/destruct
+00065         static CTwoPhaser* NewLC(TInt aInt1)
+00066                 { // construct and leave on the clean-up stack
+00067                 CTwoPhaser* self=new (ELeave) CTwoPhaser; // new CTwoPhaser, initialized to binary zeroes
+00068                 CleanupStack::PushL(self); // push to clean-up stack
+00069                 self->ConstructL(aInt1); // construct
+00070                 return self; // return new object
+00071                 };
+00072         static CTwoPhaser* NewL(TInt aInt1)
+00073                 { // construct and don't leave on clean-up stack
+00074                 CTwoPhaser* self=CTwoPhaser::NewLC(aInt1); // construct and leave on clean-up stack
+00075                 CleanupStack::Pop(); // pop from clean-up stack
+00076                 return self; // return new object
+00077                 };
+00078         virtual ~CTwoPhaser()
+00079                 {
+00080                 delete iOnePhaser; // just destroy anything we point to
+00081                 iTimer.Close(); // close timer
+00082                 }
+00083         // other functions
+00084         void Print()
+00085                 {
+00086                 _LIT(KFormat2,"CTwoPhaser {TInt %d, TInt %d, RTimer, ");
+00087                 console->Printf(KFormat2, iInt1, iInt2);
+00088                 iOnePhaser->Print();
+00089                 _LIT(KtxtCloseCurly,"}");
+00090                 console->Printf(KtxtCloseCurly);
+00091                 }
+00092 protected: // functions
+00093         // construct support
+00094         void ConstructL(TInt aInt1)
+00095                 { // do the work involved in construction
+00096                 iInt1=aInt1; // assign iInt1 from argument
+00097                 User::LeaveIfError(iTimer.CreateLocal()); // initialize timer
+00098                 iOnePhaser=COnePhaser::NewL(); // make a new one-phaser
+00099                 }
+00100         };
+00101 
+00102 // abstract class derived from CBase
+00103 
+00104 class CAbstract : public CBase
+00105         {
+00106 public: // data
+00107         CTwoPhaser* iTwoPhaser; // a contained object
+00108 public: // functions
+00109         void SomeFunction(TInt aInt)
+00110                 { // request some function
+00111                 _LIT(KTxtbeginSomeFunction,"beginning to do SomeFunction()\n");
+00112                 console->Printf(KTxtbeginSomeFunction);
+00113                 DoSomeFunction(aInt); // invoke virtual function
+00114                 _LIT(KTxtfinishSomeFunction,"finished doing SomeFunction()\n");
+00115                 console->Printf(KTxtfinishSomeFunction);
+00116                 }
+00117         virtual ~CAbstract()
+00118                 {
+00119                 delete iTwoPhaser;
+00120                 }
+00121 protected:
+00122         virtual void DoSomeFunction(TInt aInt) const =0;
+00123                 // implement heart of some function, in derived class
+00124         void ConstructL(TInt aInt)
+00125                 { // second phase of constructor
+00126                 iTwoPhaser=CTwoPhaser::NewL(aInt);
+00127                         // construct embedded object
+00128                 }
+00129         };
+00130 
+00131 // class derived from above
+00132 
+00133 class CConcrete : public CAbstract
+00134         {
+00135 public: // data
+00136         COnePhaser* iOnePhaser; // some extra data
+00137 public: // functions
+00138         // construct/destruct
+00139         static CConcrete* NewLC(TInt aInt)
+00140                 { // construct and leave on the clean-up stack
+00141                 CConcrete* self=new (ELeave) CConcrete; // new object, C++ constructor
+00142                 CleanupStack::PushL(self); // push to clean-up stack
+00143                 self->ConstructL(aInt); // CBase constructor
+00144                 return self; // return new object
+00145                 };
+00146         static CConcrete* NewL(TInt aInt)
+00147                 { // construct and don't leave on clean-up stack
+00148                 CConcrete* self=CConcrete::NewLC(aInt); // construct and leave on clean-up stack
+00149                 CleanupStack::Pop(); // pop from clean-up stack
+00150                 return self; // return new object
+00151                 };
+00152         virtual ~CConcrete()
+00153                 {
+00154                 delete iOnePhaser; // destroy member
+00155                 }
+00156         // protocol
+00157         virtual void DoSomeFunction(TInt aInt) const
+00158                 { // implementation of base class's pure-virtual function
+00159                 _LIT(KFormat3,"CConcrete::DoSomething(%d)\n");
+00160                 console->Printf(KFormat3, aInt);
+00161                 }
+00162 protected:
+00163         // construct/destruct
+00164         void ConstructL(TInt aInt)
+00165                 { // second phase of construction
+00166                 CAbstract::ConstructL(aInt); // base class constructor
+00167                 iOnePhaser=COnePhaser::NewL(); // contained member constructor
+00168                 }
+00169         };
+00170 
+00171 // do the example
+00172 LOCAL_C void doExampleL()
+00173     {
+00174         // two-phase object
+00175         CTwoPhaser* twoPhaser=CTwoPhaser::NewLC(5);
+00176                         // new two-phase object
+00177         twoPhaser->Print(); // print it
+00178         _LIT(KTxtNewLine,"\n");
+00179         console->Printf(KTxtNewLine);  // with trailing new-line
+00180         CleanupStack::PopAndDestroy(); // two-phase object
+00181         // concrete instance of an abstract class
+00182         CAbstract* abstract=CConcrete::NewLC(9);
+00183                 // new concrete object, but refer to it with abstract pointer
+00184         abstract->SomeFunction(11); // do something with it
+00185         CleanupStack::PopAndDestroy(); // abstract object
+00186         }
+