examples/Base/BufsAndStrings/Desc/Pointer/Pointer.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 basic ideas of
00015 // pointer descriptors. 
00016 //
00017 
00018 #include "CommonFramework.h"
00019 
00020 //
00021 // Common literal text
00022 //
00023 _LIT(KTxtHiTHere,"Hi there");
00024 _LIT(KTxtHaveNiceDay,"Have a nice day!");
00025 
00026 //
00027 // Common format strings
00028 //
00029 _LIT(KCommonFormat1,"\"%s\"\n");
00030 _LIT(KCommonFormat3,"length=%d; size=%d;\n");
00031 _LIT(KCommonFormat5,"Ptr()=%x; Length()=%d; Size()=%d\n");
00032 _LIT(KCommonFormat16,"MaxLength()=%d\n");
00033 _LIT(KCommonFormat17,"\"%S\"; ");
00034 _LIT(KCommonFormat18,"Length()=%d; Size()=%d; ");
00035 
00036 // Do the example
00037 LOCAL_C void doExampleL()
00038     {
00039                                 // Define a constant C style (ASCII) string
00040         const TText8* cstr8 = (TText8*)"Hello World!";
00041 
00042                                 // Look at it.
00043 
00044         TBuf<12> temp;
00045         temp.Copy(TPtrC8(cstr8));
00046         console->Printf(temp);
00047 
00048                                 // A TPtrC8 descriptor represents the
00049                         // ASCII text; contrast this with the
00050                         // basic C string  
00051         TPtrC8 ptrC8(cstr8);
00052 
00053                                 // Look at:
00054                                 //   1. Address of C string
00055                                 //   2. Length of the C string
00056                                 //   3. Size of the string.
00057                                 // Size is 13 bytes to allow for 
00058                                 // the terminating NULL.
00059                     // 
00060         _LIT(KFormat2,"\nNarrow C string at %x; ");
00061         console->Printf(KFormat2,cstr8);
00062         console->Printf(KCommonFormat3,12,sizeof("Hello World!"));
00063 
00064                                 // Look at:
00065                                 //   1. Address of descriptor
00066                                 //   2. Address of descriptor data area
00067                                 //   3. Length  of descriptor
00068                                 //   4. Size of descriptor
00069                                 // Address of descriptor data area is the 
00070                                 // same as the address of the C string. 
00071                                 // The Size of the descriptor data is only
00072                                 // 12 bytes (1 byte for each character).
00073         _LIT(KFormat4,"8-bit pointer-descriptor at %x; ");
00074         console->Printf(KFormat4,&ptrC8);
00075         console->Printf(KCommonFormat5,ptrC8.Ptr(),ptrC8.Length(),ptrC8.Size());                
00076                                                                 
00077                 
00078                                 // Define a constant C style (Wide) string
00079         const TText16*  cstr16 = (TText16*)L"Hello World!";
00080 
00081                                 // A TPtrC16 descriptor represents the
00082                         // wide (i.e. double-byte character) text;
00083                         // contrast this with the basic C string.  
00084         TPtrC16 ptrC16(cstr16);
00085         
00086         _LIT(KFormat7,"\nWide C string at %x; ");
00087         console->Printf(KFormat7,cstr16);
00088         console->Printf(KCommonFormat3,12,sizeof(L"Hello World!"));
00089         
00090                                 // Look at:
00091                                 //   1. Address of descriptor
00092                                 //   2. Address of descriptor data area
00093                                 //   3. Length  of descriptor
00094                                 //   4. Size of descriptor
00095                                 // Address of descriptor data area is the
00096                                 // same as the address of the C string.
00097                                 // The size of descriptor data is only
00098                                 // 24 bytes (2 bytes for each character).
00099         _LIT(KFormat6,"16-bit pointer-descriptor at %x; ");
00100         console->Printf(KFormat6,&ptrC16);
00101         console->Printf(KCommonFormat5,ptrC16.Ptr(),ptrC16.Length(),ptrC16.Size());             
00102         
00103                 
00104                                 // Use the _S macro to define a constant 
00105                                 // C style string of the appropriate width.
00106                                 // The TText variant is defined at build
00107                                 // time as  TText16 
00108                                 // (In earlier times this could also have been TText8,
00109                                 //  but in all current versions, TText16 is the standard).
00110         const TText* cstr = _S("Hello World!"); 
00111 
00112                                 // TPtrC descriptor represents the text;
00113                                 // the TPtrC variant is defined at build 
00114                                 // time as TPtrC16.
00115         TPtrC ptrc(cstr);
00116         
00117         _LIT(KFormat8,"\nBuild-dependent TText at %x; ");
00118         console->Printf(KFormat8,cstr);
00119         console->Printf(KCommonFormat3,12,sizeof( 
00120                                                                   #ifdef _UNICODE
00121                                                                   L"Hello world!"
00122                                                                   #else
00123                                                                   "Hello world!"
00124                                                                   #endif
00125                                                   )
00126                                    );
00127         
00128                                 // Look at descriptor basics.
00129         _LIT(KTxtBuildDependentptdesc,"Build-dependent pointer-descriptor");
00130         console->Printf(KTxtBuildDependentptdesc);
00131         
00132         _LIT(KFormat9," at %x; ");
00133         console->Printf(KFormat9,&ptrc);
00134         _LIT(KFormat10,"Ptr()=%x;\n");
00135         console->Printf(KFormat10,ptrc.Ptr());
00136         _LIT(KFormat11," Length()=%d; Size()=%d\n");
00137         console->Printf(KFormat11,ptrc.Length(),ptrc.Size());
00138 
00139                                 // The _LIT macro is most useful. It constructs
00140                     // a family of constant descriptor classes TLitC<Tint>. 
00141                     // The constant generated by the _LIT macro:
00142                     //   1. can be passed as 'const TDesC&' type
00143                     //   2. has an address-of operator 'operator&()' which returns a 'const TDesC*' type
00144                     //   3. can be passed as a TRefByValue<const TDesC>
00145                                 //
00146                                 // The _L macro constructs a TPtrC but should be avoided 
00147                     // where possible on the grounds of efficiency.
00148                     // Use the _LIT macro instead.
00149                                 
00150         console->Printf(_L("\nThe _L macro constructs a TPtrC"));
00151         // * * * * * * * * * * * * * * * * * * * * * * * * * * * *
00152         // * * * * * * * * * * * * * * * * * * * * * * * * * * * *
00153         
00154         _LIT(KTxtTPtrBasicConcepts,"\n-->TPtr basic concepts");
00155         console->Printf(KTxtTPtrBasicConcepts);
00156         _LIT(KTxtPressToContinue," (press any key to continue)\n");
00157         console->Printf(KTxtPressToContinue);
00158         console->Getch();
00159                                         
00160                                 // Set up an area and initialise to a 
00161                                 // C style string (including the NULL).
00162                                 // The need for the NULL forces cstr to
00163                                 // have a length of 16.
00164         TText str[16] =  {'H', 'a', 'v', 'e', ' ', 'a',
00165                                           ' ', 'n', 'i', 'c', 'e',
00166                                           ' ', 'd', 'a', 'y', '\0'};
00167 
00168                                 // Look at it.
00169         console->Printf(KCommonFormat1,&str[0]);
00170 
00171                                 // TPtr descriptor represents the text.
00172                                 // Descriptor length is 15 but max length
00173                                 // is 16. The descriptor does not need the
00174                                 // terminating NULL, so in this example,
00175                                 // the last data position is spare. 
00176         TPtr  ptr(&str[0],15,16);
00177 
00178                                 // Look at:
00179                                 //   1. Address of the C string
00180                                 //   2. Length of the C string
00181                                 //   3. Size of the string
00182                                 // Size is 16 bytes to allow for
00183                                 // the terminating NULL.
00184         _LIT(KFormat12,"C string at %x; ");
00185         console->Printf(KFormat12,str);
00186         _LIT(KFormat13,"length=%d; size=%d\n");
00187         console->Printf(KFormat13,15,sizeof(str));
00188 
00189                         // Look at:
00190                                 //   1. Address of descriptor
00191                                 //   2. Address of descriptor area
00192                                 //   3. Length of descriptor
00193                                 //   4. Size of descriptor
00194                                 //   5. Max length of descriptor 
00195                                 // Address of descriptor data area is the 
00196                                 // same as the address of cstr[]. The
00197                                 // descriptor length is 15 but the maximum
00198                                 // length is 16.
00199         _LIT(KFormat14,"Descriptor at %x; ");
00200         console->Printf(KFormat14,&ptr);
00201         _LIT(KFormat15,"Ptr()=%x; Length()=%d; Size()=%d; ");
00202         console->Printf(KFormat15,ptr.Ptr(),ptr.Length(),ptr.Size());
00203         console->Printf(KCommonFormat16,ptr.MaxLength());
00204 
00205                                 // The data can be replaced using the 
00206                                 // assignment operator. Note the reference to
00207                     // the TLitC<> KTxtHiTHere constructed using the _LIT macro.
00208         ptr = KTxtHiTHere;                       
00209 
00210                                 // Length of descriptor is now 8 but maximum
00211                                 // length remains at 16.
00212                                 // Size is 16 
00213                                 // Text in ptr's data area (i.e. in the area 
00214                                 // defined by str[]) is 
00215                                 // now "Hi there")
00216         console->Printf(KCommonFormat17,&ptr);
00217         console->Printf(KCommonFormat18,ptr.Length(),ptr.Size());
00218         console->Printf(KCommonFormat16,ptr.MaxLength());
00219                                         
00220                                 // Length can be changed; data represented 
00221                                 // by the descriptor is now "Hi"
00222         ptr.SetLength(2);
00223                     
00224         console->Printf(KCommonFormat17,&ptr);
00225         console->Printf(KCommonFormat18,ptr.Length(),ptr.Size());
00226         console->Printf(KCommonFormat16,ptr.MaxLength());
00227 
00228                                 // Length can be set to zero; NO data 
00229                                 // is now represented by the
00230                                 // descriptor but maximum length is still 16
00231         ptr.Zero();
00232         console->Printf(KCommonFormat17,&ptr);
00233         console->Printf(KCommonFormat18,ptr.Length(),ptr.Size());
00234         console->Printf(KCommonFormat16,ptr.MaxLength());
00235 
00236                                 // Replace text with text of length 16, 
00237                                 // the maximum. 
00238         ptr = KTxtHaveNiceDay;
00239         console->Printf(KCommonFormat17,&ptr);
00240         console->Printf(KCommonFormat18,ptr.Length(),ptr.Size());
00241         console->Printf(KCommonFormat16,ptr.MaxLength());
00242 
00243                                 // adding another character causes panic !!
00244                                 // length would be > maximum.
00245                                 // 
00246                                 // Remove the "//" marks on the next line
00247                                 // to see this happen
00248         //ptr.Append('@');
00249     }
00250 
00251 
00252     
00253 
00254 
00255 
00256 
00257         
00258         

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