TB10.1 Example Applications: examples/Base/BufsAndStrings/rbufexample/rbufexample.cpp Source File

00001 // Copyright (c) 2008-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 // This example program demonstrates how to use the resizable buffer descriptor class RBuf.
-00015 //
-00016 
-00017 
-00018 
-00022 #include "rbufexample.h"
-00023 
-00024 const TInt KLargeBufSize = 15;
-00025 const TInt KSmallBufSize = 3;
-00026 const TInt KMedBufSize = 7;
-00027 
-00028 _LIT(KFailed, "\n Error occurred");
-00029 _LIT(KPressAKey, "\n\n Press any key to continue the example\n");
-00030 _LIT(KLength,"\n  Length= %d");
-00031 _LIT(KMaxLength,"\n  MaxLength= %d");
-00032 _LIT(KBuffer1,"11111");
-00033 _LIT(KBuffer2,"22222");
-00034 
-00038 CRBufExample::CRBufExample()
-00039         {
-00040         }
-00041 
-00042 void CRBufExample::ConstructL()
-00043         {
-00044         _LIT(KTitle," RBuf Example");
-00045         iConsole = Console::NewL(KTitle, TSize(KConsFullScreen, KConsFullScreen));
-00046         
-00047         _LIT(KWelcome," Welcome to the RBuf example application");
-00048         iConsole->Printf(KWelcome);
-00049         
-00050         _LIT(KPressAKeyMsg, "\n\n Press any key to step through the example\n");
-00051         iConsole->Printf(KPressAKeyMsg );
-00052         iConsole->Getch();
-00053         }
-00054 
-00058 CRBufExample::~CRBufExample()
-00059         {
-00060         delete iConsole;
-00061         }
-00062 
-00067 CRBufExample* CRBufExample::NewL()
-00068         {
-00069         CRBufExample* self=new(ELeave)CRBufExample();
-00070         CleanupStack::PushL(self);
-00071         self->ConstructL();
-00072         CleanupStack::Pop(self);
-00073         return self;
-00074         }
-00075     
-00079 void CRBufExample::CreateRBufL()
-00080         {
-00081         _LIT(KCreate,"\n Creating an RBuf: \n");
-00082 
-00083         iConsole->Printf(KCreate);
-00084         
-00085         RBuf buf;
-00086         
-00087         // Create an empty buffer descriptor
-00088         // The length is zero, the maxlength is 3
-00089         User::LeaveIfError(buf.Create(KSmallBufSize));
-00090         CleanupClosePushL(buf);
-00091         
-00092         // Get the length of the buffer
-00093         TInt length= buf.Length();
-00094         
-00095         // Get the maximum length of the buffer
-00096         TInt maxLength= buf.MaxLength();
-00097         
-00098         // Check that length and maximum length are not equal because it was created using Create()
-00099         if(length != maxLength)
-00100                 {
-00101                 _LIT(KUsingCreate, "\n Using Create() API: ");
-00102                 iConsole->Printf(KUsingCreate);
-00103                 iConsole->Printf(KLength, length);
-00104                 iConsole->Printf(KMaxLength, maxLength);
-00105                 }
-00106         else
-00107                 {
-00108                 iConsole->Printf(KFailed);
-00109                 }       
-00110 
-00111         // Deallocate the memory assigned to the buffer
-00112         CleanupStack::PopAndDestroy(&buf);
-00113         
-00114         // Create buffer descriptor
-00115         // The length is 3, the maxlength is 3
-00116         User::LeaveIfError(buf.CreateMax(KSmallBufSize));
-00117         CleanupClosePushL(buf);
-00118         
-00119         // Get the length of the buffer.
-00120         length= buf.Length();
-00121         
-00122         // Get the maximum length of the buffer.
-00123         maxLength=buf.MaxLength();
-00124         
-00125         // Check that length and maximum length are equal because it was created using CreateMax().
-00126         if(length == maxLength)
-00127                 {
-00128                 _LIT(KCreateInAdvance, "\n Using CreateMax() API: ");
-00129                 iConsole->Printf(KCreateInAdvance);     
-00130                 iConsole->Printf(KLength, length);
-00131                 iConsole->Printf(KMaxLength, maxLength);
-00132                 }
-00133         else
-00134                 {
-00135                 iConsole->Printf(KFailed);
-00136                 }       
-00137         
-00138         // Deallocate the memory assigned to the buffer.
-00139         CleanupStack::PopAndDestroy(&buf);
-00140         } 
-00141         
-00145 void CRBufExample::CreateRBufFromExistingDesL()
-00146         {
-00147         RBuf buf;
-00148         
-00149         // Create a buffer descriptor, initialised with some text
-00150         buf.CreateL(KBuffer1);
-00151         
-00152         _LIT(KCreateFromExistingDes, "\n From an existing descriptor ");
-00153         iConsole->Printf(KCreateFromExistingDes);
-00154 
-00155         // Deallocates the memory assigned to the buffer
-00156         buf.Close();
-00157         } 
-00158         
-00162 void CRBufExample::CreateRBufFromHBufCL()
-00163         {
-00164         // Create a pointer to a heap descriptor
-00165         HBufC* hptr = HBufC::NewL(KBuffer1().Length());
-00166         
-00167         // Assign some data to the heap descriptor.
-00168         *hptr = KBuffer1; 
-00169         
-00170         RBuf buf;
-00171         
-00172         // Assign the HBufC to the buffer. This transfers ownership of the heap descriptor.
-00173         buf.Assign(hptr);
-00174         
-00175         _LIT(KCreateFromHBufC, "\n From HBufC ");
-00176         iConsole->Printf(KCreateFromHBufC);
-00177         
-00178         // Deallocate the memory assigned to the buffer. 
-00179         // There is no need to free the HBufC because Assign() transferred ownership.
-00180         buf.Close(); 
-00181         }
-00182         
-00186 void CRBufExample::CreateRBufFromAnotherRBufL()
-00187         {
-00188         RBuf buf;
-00189         
-00190         // Create a buffer descriptor, initialised with some text
-00191         User::LeaveIfError(buf.Create(KBuffer1));
-00192                 
-00193         RBuf targetBuf;
-00194         
-00195         // Assign one buffer to the other. 
-00196         // Transfers ownership of the source buffer's memory to the target buffer.
-00197         // Note that targetBuf should have no memory allocated to it beforehand
-00198         // otherwise a memory leak will occur.
-00199         targetBuf.Assign(buf);
-00200         
-00201         _LIT(KCreateFromAnotherRBuf, "\n From another RBuf");
-00202         iConsole->Printf(KCreateFromAnotherRBuf);
-00203 
-00204         // Deallocate the memory assigned to the buffer.
-00205         targetBuf.Close();
-00206         }
-00207                 
-00211 void CRBufExample::CreateRBufUsingRReadStreamL()
-00212         {
-00213         // A handle to a file server session. 
-00214         // This is used to create and write to/read from a file.
-00215         RFs fs;
-00216         
-00217         // Connect to the file server.
-00218         User::LeaveIfError(fs.Connect());
-00219         CleanupClosePushL(fs);
-00220         // Create the session path at the process's private path on the system drive.
-00221         User::LeaveIfError(fs.CreatePrivatePath(RFs::GetSystemDrive()));
-00222 
-00223         // Set the session path to point to the process's private path on the system drive.
-00224         User::LeaveIfError(fs.SetSessionToPrivate(RFs::GetSystemDrive()));
-00225         
-00226         // Declare a file stream to write to.
-00227         RFileWriteStream wStream;
-00228         
-00229         _LIT(KFileName,"stream.dat");
-00230         
-00231         // Create a file, associates it with the stream, and prepares the stream for writing.
-00232         User::LeaveIfError(wStream.Replace(fs, KFileName, EFileWrite));
-00233         CleanupClosePushL(wStream);
-00234         
-00235         _LIT(KText, "RBuf Example");
-00236 
-00237         // Write some text to the stream.
-00238         wStream << KText();
-00239         wStream.CommitL();
-00240         CleanupStack::PopAndDestroy(&wStream);
-00241         
-00242         // Declare a file stream to read from.
-00243         RFileReadStream rStream;
-00244         
-00245         // Open the file
-00246         User::LeaveIfError(rStream.Open(fs, KFileName, EFileRead));
-00247         CleanupClosePushL(rStream);
-00248         
-00249         RBuf buf;
-00250         CleanupClosePushL(buf);
-00251         
-00252         // Create the buffer by passing the open stream object to CreateL().
-00253         buf.CreateL(rStream, KLargeBufSize);
-00254         
-00255         _LIT(KCreateUsingRReadStream, "\n Using RReadStream ");
-00256         iConsole->Printf(KCreateUsingRReadStream);
-00257         
-00258         // Deallocate the memory assigned to the buffer, close the stream and close the file server connection
-00259         CleanupStack::PopAndDestroy(&buf);
-00260         CleanupStack::PopAndDestroy(&rStream);
-00261         CleanupStack::PopAndDestroy(&fs);
-00262         }
-00263 
-00267 void CRBufExample::CreateRBufFromAllocatedMemoryL()
-00268         {
-00269         RBuf buf;
-00270         
-00271         // Allocate some memory.
-00272         TUint16* allocatedMemory = static_cast<TUint16*>( User::Alloc( KLargeBufSize * sizeof( TUint16) ) ) ;
-00273 
-00274         // Transfer ownership of the memory to the descriptor.
-00275         buf.Assign(allocatedMemory, KLargeBufSize);
-00276         
-00277         _LIT(KCreateFromAllocatedMemory, "\n By transferring ownership of allocated memory");
-00278         iConsole->Printf(KCreateFromAllocatedMemory);
-00279         
-00280         iConsole->Printf(KPressAKey);
-00281         iConsole->Getch();
-00282         
-00283         // Deallocate the memory assigned to the buffer.
-00284         // There is no need to free memory here because Assign() transferred ownership.
-00285         buf.Close(); 
-00286         }
-00287 
-00291 void CRBufExample::SwapTwoRBufsL()
-00292         {
-00293         _LIT(KSwapAndCopy,"\n Swapping and copying data: ");
-00294         iConsole->Printf(KSwapAndCopy);
-00295         
-00296         RBuf buf1;
-00297         
-00298         // Create a buffer descriptor, initialised with some text
-00299         User::LeaveIfError(buf1.Create(KBuffer1));
-00300         CleanupClosePushL(buf1);
-00301         
-00302         RBuf buf2;
-00303         
-00304         // Create a second buffer descriptor, initialised with some text
-00305         User::LeaveIfError(buf2.Create(KBuffer2));
-00306         CleanupClosePushL(buf2);
-00307         
-00308         _LIT(KBeforeSwapping, "\n Before swapping: ");
-00309         iConsole->Printf(KBeforeSwapping);
-00310         
-00311         // Print out the contents of the 2 descriptors
-00312         _LIT(KPrintFirstdata,"\n  Data present in first descriptor is: ");
-00313         iConsole->Printf(KPrintFirstdata);      
-00314         iConsole->Printf(buf1);
-00315         
-00316         _LIT(KPrintSecondData,"\n  Data present in second descriptor is: ");
-00317         iConsole->Printf(KPrintSecondData);     
-00318         iConsole->Printf(buf2);
-00319         
-00320         // Swap them and print out the new contents
-00321         buf1.Swap(buf2);
-00322         
-00323         _LIT(KAfterSwapping, "\n After swapping: ");
-00324         iConsole->Printf(KAfterSwapping);
-00325         
-00326         iConsole->Printf(KPrintFirstdata);      
-00327         iConsole->Printf(buf1);
-00328         
-00329         iConsole->Printf(KPrintSecondData);     
-00330         iConsole->Printf(buf2);
-00331         
-00332         _LIT(KSwap, "\n Swapping between two RBufs is successful");
-00333         iConsole->Printf(KSwap);
-00334                         
-00335         // Deallocate memory assigned to the 2 buffer descriptors.
-00336         CleanupStack::PopAndDestroy(2); // buf1, buf2
-00337         }
-00338         
-00342 void CRBufExample::CopyDataUsingAssignmentOperatorL()
-00343         {
-00344         RBuf buf1;
-00345         
-00346         // Create a buffer descriptor, initialised with some text
-00347         buf1.Create(KBuffer1);
-00348         CleanupClosePushL(buf1);
-00349 
-00350         RBuf buf2;
-00351         
-00352         // Create a second buffer descriptor, initialised with some text
-00353         User::LeaveIfError(buf2.Create(KBuffer2));
-00354         CleanupClosePushL(buf2);
-00355 
-00356         // Copy data using assignment operator from one to the other. 
-00357         // Target buffer must be long enough, otherwise a panic occurs.
-00358         buf2= buf1;
-00359         
-00360         // Check the value of the buffers .
-00361         if (buf1==buf2)
-00362                 {
-00363                 _LIT(KCopyDataUsingAssignmentOperator,"\n Copying data using assignment operator from descriptor, and RBuf is successful");
-00364                 iConsole->Printf(KCopyDataUsingAssignmentOperator);
-00365                 }
-00366         else
-00367                 {
-00368                 iConsole->Printf(KFailed);      
-00369                 }       
-00370         
-00371         iConsole->Printf(KPressAKey);
-00372     iConsole->Getch();
-00373         
-00374         // Deallocate memory assigned to the 2 buffer descriptors.
-00375         CleanupStack::PopAndDestroy(2); // buf1, buf2
-00376         }
-00377         
-00381 void CRBufExample::ReallocateAndFreeTheMemoryBufferL()
-00382         {
-00383         _LIT(KReAllocAndFree,"\n Realloc and free:");
-00384         iConsole->Printf(KReAllocAndFree);
-00385         
-00386         RBuf buf;
-00387         
-00388         // Create empty buffer descriptor with max length of KSmallBufSize.
-00389         User::LeaveIfError(buf.Create(KSmallBufSize));
-00390         
-00391         // Get the length of the buffer.
-00392         TInt length= buf.Length();
-00393         
-00394         // Get the maximum length of the buffer.
-00395         TInt maxLength= buf.MaxLength();
-00396         
-00397         _LIT(KBeforeReAlloc,"\n Before ReAlloc: ");
-00398         iConsole->Printf(KBeforeReAlloc);
-00399         
-00400         // Print out the length and max length
-00401         iConsole->Printf(KLength, length);
-00402         iConsole->Printf(KMaxLength, maxLength);        
-00403 
-00404         // Re-allocate the buffer descriptor. Length doesnt change but maxlength does.
-00405         User::LeaveIfError(buf.ReAlloc(KMedBufSize));
-00406         
-00407         // Get the length of the buffer.
-00408         length= buf.Length();
-00409         
-00410         // Get the maximum length of the reallocated buffer.
-00411         maxLength= buf.MaxLength();
-00412         
-00413         _LIT(KAfterReAlloc,"\n After ReAlloc: ");
-00414         iConsole->Printf(KAfterReAlloc);
-00415 
-00416         // Print out the length and new max length
-00417         iConsole->Printf(KLength, length);
-00418         iConsole->Printf(KMaxLength, maxLength);        
-00419         
-00420         // Free the memory buffer. It sets the length and maxlength to zero.
-00421         User::LeaveIfError(buf.ReAlloc(0));
-00422         
-00423         // Get the length of the buffer.
-00424         length= buf.Length();
-00425         
-00426         // Get the maximum length of the buffer.
-00427         maxLength= buf.MaxLength();
-00428         
-00429         _LIT(KFreeBuffer,"\n After free: ");
-00430         iConsole->Printf(KFreeBuffer);
-00431         
-00432         iConsole->Printf(KLength, length);
-00433         iConsole->Printf(KMaxLength, maxLength);
-00434         }
-00435         
-00439 void CRBufExample::ReplaceAndModifyTheDataL()
-00440         {
-00441         RBuf buf;
-00442         
-00443         // Create a buffer descriptor, initialised with some text
-00444         User::LeaveIfError(buf.Create(KBuffer1)); 
-00445         CleanupClosePushL(buf);
-00446                         
-00447         _LIT(KReplaceAndModify,"\n Replace and modify: ");
-00448         iConsole->Printf(KReplaceAndModify);
-00449         
-00450         // Print the original data present in the buffer.
-00451         _LIT(KOriginalData,"\n Data present in RBuf is: ");
-00452         iConsole->Printf(KOriginalData);
-00453         iConsole->Printf(buf);
-00454         
-00455         TInt pos= 1;
-00456         
-00457         _LIT(KReplacedMessage,"22");
-00458         
-00459         TInt length= KReplacedMessage().Length();
-00460 
-00461         // Replace a portion of the data in the buffer descriptor.
-00462         buf.Replace(pos,length, KReplacedMessage);
-00463         
-00464         // Print the buffer's new contents.
-00465         _LIT(KReplacedData,"\n After replacement, data held in RBuf is: ");
-00466         iConsole->Printf(KReplacedData);
-00467         iConsole->Printf(buf);
-00468         
-00469         pos=3;
-00470         length=1;
-00471         
-00472         // Delete the replacement text.
-00473     buf.Delete(pos,length);
-00474     
-00475     // Print the buffer's contents again.
-00476     _LIT(KModifiedData,"\n After modification, data held in RBuf is: ");
-00477     iConsole->Printf(KModifiedData);
-00478     iConsole->Printf(buf);
-00479     
-00480     _LIT(KReplaceAndModifyData,"\n Replacing and modifying the data held in RBuf is successful");
-00481     iConsole->Printf(KReplaceAndModifyData);
-00482     
-00483     // Deallocate the memory assigned to the buffer. 
-00484         CleanupStack::PopAndDestroy(&buf);
-00485         }
-00486         
-00490 void CRBufExample::CleanUpRulesL()
-00491         {
-00492         RBuf buf;
-00493         
-00494         // Create a buffer descriptor, initialised with some text
-00495         User::LeaveIfError(buf.Create(KBuffer1));
-00496         
-00497         // To avoid memory leaks use RBuf::CleanupClosePushL() to push a cleanup item for the RBuf onto the cleanup stack.
-00498         // The effect is to cause Close() to be called on the buffer descriptor if a leave occurs, 
-00499         // or when CleanupStack::PopAndDestroy() is called.
-00500         buf.CleanupClosePushL();
-00501         
-00502         // Causes Close() to be called to deallocate the memory assigned to the buffer.
-00503         CleanupStack::PopAndDestroy(&buf);
-00504         
-00505         _LIT(KCleanUp,"\n RBuf cleanup is successful");
-00506         iConsole->Printf(KCleanUp);
-00507         
-00508         _LIT(KExitMsg, "\n\n Press any key to exit the example");
-00509     iConsole->Printf(KExitMsg);
-00510         iConsole->Getch();
-00511         }       
-00512 
-00513 void MainL()
-00514         {
-00515         CRBufExample* app= CRBufExample::NewL();
-00516         CleanupStack::PushL(app);
-00517         
-00518         // Creates empty RBuf.
-00519         app->CreateRBufL();
-00520         
-00521         // Creates RBuf from an existing descriptor.
-00522         app->CreateRBufFromExistingDesL(); 
-00523         
-00524         // Creates RBuf from an HBufC.
-00525         app->CreateRBufFromHBufCL();
-00526         
-00527         // Creates RBuf from another RBuf.
-00528         app->CreateRBufFromAnotherRBufL();
-00529         
-00530         // Create RBuf using RReadStream
-00531         app->CreateRBufUsingRReadStreamL();
-00532         
-00533         // Creates RBuf from allocated memory.
-00534         app->CreateRBufFromAllocatedMemoryL();
-00535                 
-00536         // Swaps two RBufs.
-00537         app->SwapTwoRBufsL();
-00538         
-00539         // Copies data using assignment operator.
-00540         app->CopyDataUsingAssignmentOperatorL();
-00541         
-00542         // Reallocates and frees the memory buffer.
-00543         app->ReallocateAndFreeTheMemoryBufferL();
-00544         
-00545         // Replaces and modifies the data in the descriptor.
-00546         app->ReplaceAndModifyTheDataL();
-00547         
-00548         // Demonstrates cleanup.
-00549         app->CleanUpRulesL();
-00550         
-00551         CleanupStack::PopAndDestroy(app);
-00552         } 
-00553 
-00554 GLDEF_C TInt E32Main()
-00555         {
-00556         __UHEAP_MARK;
-00557 
-00558         CTrapCleanup* cleanup = CTrapCleanup::New();
-00559         if(cleanup == NULL)
-00560                 {
-00561                 return KErrNoMemory;
-00562                 }
-00563         TRAPD(err, MainL());
-00564         delete cleanup;
-00565 
-00566         if(err !=KErrNone)
-00567                 {
-00568                 User::Panic(KFailed, err);
-00569                 }       
-00570                 
-00571         __UHEAP_MARKEND;
-00572         return KErrNone;
-00573         }
-00574   
-00575   
-00576   
-00577   
-00578  
-00579  
-00580  
-