examples/Base/MemMan/Cleanup/NewLC/NewLC.cpp

00001 /*
00002 Copyright (c) 2000-2010 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.
00003 
00004 Redistribution and use in source and binary forms, with or without
00005 modification, are permitted provided that the following conditions are met:
00006 
00007 * Redistributions of source code must retain the above copyright notice, this
00008   list of conditions and the following disclaimer.
00009 * Redistributions in binary form must reproduce the above copyright notice,
00010   this list of conditions and the following disclaimer in the documentation
00011   and/or other materials provided with the distribution.
00012 * Neither the name of Nokia Corporation nor the names of its contributors
00013   may be used to endorse or promote products derived from this software
00014   without specific prior written permission.
00015 
00016 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
00017 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
00018 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
00019 DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
00020 FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
00021 DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
00022 SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
00023 CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
00024 OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
00025 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
00026 
00027 Description:
00028 Example shows use of the NewLC() static function.
00029 NOTE: the structure of this example is different to standard E32 examples  
00030 */
00031 
00032 
00033 #include <e32cons.h>
00034 
00035   // All messages written to this
00036 LOCAL_D CConsoleBase* console;
00037   
00038   // Flag which determines whether the doSomething() member function
00039   // of the CExample class should leave when called.
00040 LOCAL_D TBool leaveFlag = ETrue;
00041 
00042   // Parameter for __UHEAP_SETFAIL
00043   // Allocation guaranteed to fail at this number of allocation attempts;
00044   // i.e. if set to n, allocation fails on the nth attempt. 
00045   // NB only used in debug mode
00046 #ifdef _DEBUG
00047 LOCAL_D TInt allocFailNumber = 1;
00048 #endif
00049   
00050   // Function prototypes
00051 LOCAL_C void doExampleL();      
00052 LOCAL_C void callExampleL();
00053 
00054 
00055 
00057 //
00058 // -----> CExample (definition)
00059 //
00060 // The class is used by the example code
00061 //
00063 class CExample : public CBase
00064         {
00065 public :
00066         static CExample* NewLC(TInt aVal);
00067         void DoSomethingL();
00068 public :
00069         TInt iInt;
00070         };
00071 
00072 
00074 //
00075 // -----> CExample (implementation)
00076 //
00078 CExample* CExample::NewLC(TInt aVal)
00079         {
00080         CExample* self = new (ELeave) CExample;
00081         CleanupStack::PushL(self);
00082         self->iInt = aVal;
00083         return self;
00084         }
00085 
00086 
00087 void CExample::DoSomethingL() 
00088         {
00089           // Leave if the global flag is set
00090         if (leaveFlag)
00091                 {
00092                 _LIT(KMsgLeaving,"DoSomethingL leaving.\n");
00093                 console->Printf(KMsgLeaving);
00094                 User::Leave(KErrGeneral);               
00095                 }
00096         _LIT(KFormat1,"Value of iInt is %d.\n");
00097         console->Printf(KFormat1,iInt);
00098         }
00099 
00101 //
00102 // Main function called by E32
00103 //
00105 GLDEF_C TInt E32Main()
00106     {
00107           // Get cleanup stack
00108         CTrapCleanup* cleanup=CTrapCleanup::New();
00109 
00110           // Some more initialization, then do the example
00111         TRAPD(error,callExampleL());
00112           
00113           // callExampleL() should never leave.
00114         _LIT(KMsgPanicEpoc32ex,"EPOC32EX");
00115         __ASSERT_ALWAYS(!error,User::Panic(KMsgPanicEpoc32ex,error));
00116 
00117           // destroy the cleanup stack
00118         delete cleanup;
00119         
00120           // return
00121         return 0;
00122     }
00123 
00124 
00126 //
00127 //
00128 //
00130 LOCAL_C void callExampleL() 
00131     {
00132           // Initialize and call the example code under cleanup stack.
00133         _LIT(KMsgExampleCode,"Symbian platform Example Code");
00134         console = Console::NewL(KMsgExampleCode,TSize(KConsFullScreen,KConsFullScreen));
00135           // Put console onto the cleanup stack.
00136         CleanupStack::PushL(console);
00137 
00138           // Perform the example function under the protection of a 
00139           // TRAP harness.
00140         TRAPD(error,doExampleL());
00141         _LIT(KMsgOK,"ok");
00142         _LIT(KFormat2,"failed: leave code = %d");
00143         if (error)
00144                 console->Printf(KFormat2,error);
00145         else
00146                 console->Printf(KMsgOK);
00147           
00148           // Continue
00149         _LIT(KMsgPressAnyKey," [press any key]");
00150         console->Printf(KMsgPressAnyKey);
00151         console->Getch();
00152 
00153           // Remove the console object from the cleanupstack
00154           // and destroy it. 
00155         CleanupStack::PopAndDestroy();
00156     }
00157 
00158 
00160 //
00161 // Do the example
00162 //
00163 // Enriched example UsingNewL by using NewLC() instead of NewL().
00164 // The function NewLC() both allocates a CExample object and pushes
00165 // the object onto the cleanup stack
00166 //
00168 void doExampleL()
00169         {
00170           // Memory alloc fails on the 'allocFailNumber' attempt. 
00171         __UHEAP_SETFAIL(RHeap::EDeterministic,allocFailNumber);
00172           // Allocate and push onto the cleanup stack - leave if 
00173           // allocation fails.
00174         CExample* myExample = CExample::NewLC(5);
00175           // Do something that can leave.
00176         myExample->DoSomethingL();
00177           // Pop from the cleanup stack and destroy
00178         CleanupStack::PopAndDestroy();
00179         }
00180 
00181 
00182 
00183 
00184 
00185 
00186 
00187 

Generated by  doxygen 1.6.2