examples/Base/BufsAndStrings/Desc/InFunct/Infunct.cpp

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         

Generated on Thu Jan 21 10:32:55 2010 for TB10.1 Example Applications by  doxygen 1.5.3