TB10.1 Example Applications: examples/Base/BufsAndStrings/Desc/InFunct/Infunct.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 // Examples to demonstrate the use of descriptors in function interfaces.
-00015 //
-00016 
-00017 #include "CommonFramework.h"
-00018 
-00019 //
-00020 // Literal text
-00021 //
-00022 
-00023 _LIT(KDataTPtrC,"A TPtrC descriptor");
-00024 _LIT(KDataTPtr,"A TPtr descriptor");
-00025 _LIT(KDataTBufC,"A TBufC descriptor");
-00026 _LIT(KDataTBuf,"A TBuf descriptor");
-00027 _LIT(KDataHBufC,"An HBufC descriptor");
-00028 
-00029 //
-00030 // Common format strings
-00031 //
-00032 
-00033 _LIT(KCommonFormat2,"0x%02x ");
-00034 
-00035 // A set of functions called by the example code
-00036 LOCAL_C void StringRead(const TDesC& aString); 
-00037 LOCAL_C void StringWrite(TDes& aString);       
-00038 LOCAL_C void BufferRead(const TDesC8& aBuffer); 
-00039 LOCAL_C void BufferWrite(TDes8& aBuffer);       
-00040                  
-00041 // Do the example
-00042 LOCAL_C void doExampleL()
-00043     {                              
-00044                                 // We create four functions:
-00045                                 // StringRead()
-00046                                 // StringWrite()
-00047                                 // BufferRead()
-00048                                 // BufferWrite() 
-00049                                 // to illustrate the use of descriptors
-00050                                 // in function interfaces       
-00051         
-00052     TText      area[48]; 
-00053         TPtrC      ptrc;
-00054     TPtr       ptr(&area[0],48);
-00055 
-00056     TBufC<48>  bufc;
-00057         TBuf<48>   buf;
-00058         HBufC*     hbufcptr;
-00059 
-00060         hbufcptr = HBufC::NewL(48);
-00061 
-00062                                 // Set up some data     for our
-00063                                 // descriptors
-00064         ptrc.Set(KDataTPtrC);    // "A TPtrC descriptor"        
-00065         ptr       = KDataTPtr;   // "A TPtr descriptor"
-00066         bufc      = KDataTBufC;  // "A TBufC descriptor"
-00067         buf       = KDataTBuf;   // "A TBuf descriptor"
-00068         *hbufcptr = KDataHBufC;  //     "An HBufC descriptor"
-00069 
-00070                                 // We can pass a reference to all
-00071                                 // descriptor types to StringRead() but the 
-00072                                 // function cannot change the 
-00073                                 // descriptor content 
-00074         StringRead(ptrc);                    // <-- a TPtrC
-00075         StringRead(ptr);                                         //     <-- a TPtr
-00076         StringRead(bufc);                                        //     <-- a TBufC
-00077         StringRead(buf);                                         //     <-- a TBuf
-00078         StringRead(*hbufcptr);                           //     <-- an HBufC
-00079                                         
-00080                                 // We can only pass a reference to those
-00081                                 // descriptors which are derived 
-00082                                 // from TDes, to StringWrite();
-00083                                 // these are the modifiable
-00084                                 // descriptors: TPtr and TBuf. 
-00085                                 //
-00086                                 // The compiler will not permit a reference
-00087                                 // to any other descriptor type to 
-00088                                 // be passed. 
-00089   //StringWrite(ptrc);                   <-- Illegal
-00090     StringWrite(ptr);                                    //     <-- a TPtr
-00091   //StringWrite(bufc);                                   <-- Illegal
-00092         StringWrite(buf);                                        //     <-- a TBuf
-00093   //StringWrite(*hbufcptr);                              <-- Illegal
-00094 
-00095         delete hbufcptr;
-00096     
-00097         _LIT(KTxtPressToContinue," (press any key to continue)\n");
-00098         console->Printf(KTxtPressToContinue);
-00099         console->Getch();
-00100                                 
-00101         TUint8      data1[3] = {0x00,0x01,0x02};
-00102         TUint8      data2[3] = {0x03,0x04,0x05};
-00103         TUint8      data3[3] = {0x06,0x07,0x08};
-00104         TUint8      data4[3] = {0x09,0x0A,0x0B};
-00105         TUint8      data5[3] = {0x0C,0x0D,0x0E};
-00106                                                       
-00107                                 // Use the 8 bit variants explicitly for
-00108                                 // general binary data.
-00109 
-00110                                 // ptrc8's data area is data1[]
-00111                                 // ptr8's data areais data2[]
-00112         TPtrC8      ptrc8(&data1[0],3);
-00113         TPtr8       ptr8(&data2[0],3,3);
-00114 
-00115                                 // bufc8 contains a copy of data3[] data
-00116                                 // buf8 contains a copy of data4[] data
-00117                                 // hbufcptr8 contains a copy of data5[] data
-00118     TBufC8<3>  bufc8= TPtrC8(&data3[0],3);
-00119         TBuf8<3>   buf8= TPtrC8(&data4[0],3);
-00120         HBufC8*    hbufcptr8;
-00121 
-00122         hbufcptr8  = HBufC8::NewL(3);
-00123         *hbufcptr8 = TPtrC8(&data5[0],3);
-00124 
-00125                                 // We can pass a reference to all
-00126                                 // descriptor types to BufferRead()
-00127                                 // but the function cannot change the 
-00128                                 // descriptor content 
-00129         BufferRead(ptrc8);                   // <-- a TPtrC
-00130         BufferRead(ptr8);                                        //     <-- a TPtr
-00131         BufferRead(bufc8);                                       //     <-- a TBufC
-00132         BufferRead(buf8);                                        //     <-- a TBuf
-00133         BufferRead(*hbufcptr8);                          //     <-- an HBufC
-00134         
-00135                                 // We can only pass a reference to those
-00136                                 // descriptors which are derived 
-00137                                 // from TDes, to BufferWrite; these are 
-00138                                 // the modifiable descriptors: TPtr and TBuf. 
-00139                                 //
-00140                                 // The compiler will not permit a reference
-00141                                 // to any other descriptor type to 
-00142                                 // be passed. 
-00143   //BufferWrite(ptrc8);                  <-- Illegal
-00144     BufferWrite(ptr8);                                   //     <-- a TPtr
-00145   //BufferWrite(bufc8);                                  <-- Illegal
-00146         BufferWrite(buf8);                                       //     <-- a TBuf
-00147   //BufferWrite(*hbufcptr8);                     <-- Illegal                            
-00148 
-00149         delete hbufcptr8;
-00150         }
-00151 
-00152 
-00153 
-00154 // ************************************************
-00155 // Functions used by doInterface()
-00156 // ************************************************
-00157 LOCAL_C void StringRead(const TDesC& aString)
-00158         {
-00159                                 // A function which handles the content
-00160                                 // of ANY descriptor passed to it but CANNOT
-00161                                 // change that descriptor.
-00162                                 //
-00163                                 // Function displays descriptor content,
-00164                                 // length and size.
-00165                                 //
-00166                                 // All descriptors can be passed to this 
-00167                                 // function     because all descriptors are 
-00168                                 // ultimately derived from TDesC.
-00169                                 //
-00170                                 // Note, however, that all data members and
-00171                                 // function members in the TDes abstract class
-00172                                 // cannot be accessed (recall that TDes is 
-00173                                 // derived from TDesC).
-00174                                 // These include the data member containing 
-00175                                 // the maximum length and all modifying 
-00176                                 // member functions.
-00177         
-00178         _LIT(KFormat5,"\"%S\"; %d; %d\n");
-00179         console->Printf(KFormat5,&aString,aString.Length(),aString.Size());
-00180         }
-00181 
-00182 
-00183 LOCAL_C void StringWrite(TDes& aString)
-00184         {
-00185                                 // A function which handles the content
-00186                                 // of a descriptor derived from TDes;
-00187                                 // i.e. the modifiable descriptors TPtr and
-00188                                 // TBuf. 
-00189                                 //
-00190                                 // Function changes the content of the
-00191                                 // referenced descriptors and then displays
-00192                                 // their content, length, size and maximum
-00193                                 // length.
-00194                                 //
-00195                                 // Note that the references to TPtrC, TBufC
-00196                                 // and HBufC cannot be passed.  
-00197         _LIT(KTxtModStringWrite," modified by StringWrite");                    
-00198     aString.Append(KTxtModStringWrite);
-00199         _LIT(KFormat3,"\"%S\"; %d; %d; %d\n");
-00200         console->Printf(KFormat3,
-00201                     &aString,
-00202                                         aString.Length(),
-00203                                         aString.Size(),
-00204                                         aString.MaxLength()
-00205                                    );
-00206         }
-00207 
-00208 
-00209 LOCAL_C void BufferRead(const TDesC8& aBuffer)
-00210         {
-00211                                 // A function which handles the content
-00212                                 // of ANY descriptor passed to it but
-00213                                 // CANNOT change that descriptor.
-00214                                 //
-00215                                 // Function displays descriptor content,
-00216                                 // length and size.
-00217                                 //
-00218                                 // All descriptors can be passed to this 
-00219                                 // function because all descriptors are 
-00220                                 // ultimately derived from TDesC.
-00221                                 //
-00222                                 // Note, however, that all data members 
-00223                                 // and function members in the TDes abstract
-00224                                 // class cannot be accessed (recall that 
-00225                                 // TDes is derived from TDesC).
-00226                                 // These include the data member containing
-00227                                 // the maximum length and all modifying
-00228                                 // member functions.
-00229         for (TInt ix = 0; ix < aBuffer.Length(); ix++)
-00230                 console->Printf(KCommonFormat2,aBuffer[ix]);
-00231         
-00232         _LIT(KFormat4,"; %d; %d\n");
-00233         console->Printf(KFormat4,aBuffer.Length(),aBuffer.Size());      
-00234         }
-00235 
-00236 
-00237 LOCAL_C void BufferWrite(TDes8& aBuffer)
-00238         {
-00239                                 // A function which handles the content
-00240                                 // of a descriptor derived from TDes;
-00241                                 // i.e. the modifiable descriptors TPtr
-00242                                 // and TBuf
-00243                                 //
-00244                                 // Function changes the content of the 
-00245                                 // referenced descriptors and then displays
-00246                                 // their content, length, size and maximum
-00247                                 // length.
-00248                                 //
-00249                                 // Note that the references to TPtrC, TBufC
-00250                                 // and HBufC cannot be passed.
-00251 
-00252         _LIT(KTxtModBufferWrite,"Modified by BufferWrite ");                    
-00253         console->Printf(KTxtModBufferWrite);
-00254                                 
-00255         for (TInt ix = 0; ix < aBuffer.Length(); ix++)
-00256                 {
-00257                 aBuffer[ix] += 0xF0;
-00258                 console->Printf(KCommonFormat2,aBuffer[ix]);
-00259                 }
-00260 
-00261         _LIT(KFormat1,"; %d; %d; %d\n");
-00262         console->Printf(KFormat1,
-00263                             aBuffer.Length(),
-00264                                         aBuffer.Size(),
-00265                                         aBuffer.MaxLength()
-00266                                    );
-00267         }
-00268 
-00269         
-