TB10.1 Example Applications: examples/Base/BufsAndStrings/Desc/Modifier/Modifier.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 some of the modifying member
+00015 // functions of descriptors.
+00016 //
+00017 
+00018 #include "CommonFramework.h"
+00019 
+00020 //
+00021 // Common literal text 
+00022 //
+00023 _LIT(KPressAnyKeyToContinue," (press any key to continue)\n");
+00024 _LIT(KTextHelloWorld,"Hello World!");
+00025 _LIT(KTextHello,"Hello");
+00026 _LIT(KTextXYZ,"XYZ");
+00027 _LIT(KTextDinner,"D\214ner \205 la Fran\207ais");
+00028 
+00029 //
+00030 // Common format strings
+00031 //
+00032 
+00033 _LIT(KFormatfourex,"%4x");
+00034 _LIT(KFormatBufLenSizeMax,"\"%S\"; %d; %d; %d\n");
+00035 _LIT(KFormatLenSizeMax,"; %d; %d; %d\n");
+00036 _LIT(KFormatBufLen,"\"%S\"; Length()=%d; ");
+00037 _LIT(KFormatSizeMax,"Size()=%d; MaxLength()=%d\n");
+00038 _LIT(KFormatCommon,"0x%02x ");
+00039 
+00040                         // Define and implement
+00041                         // the overflow handler used
+00042                         // by the AppendFormat() example.
+00043 
+00044 class TestOverflow : public TDesOverflow
+00045         {
+00046         void Overflow(TDes& aDes);
+00047         };
+00048 
+00049 
+00050 void TestOverflow::Overflow(TDes& aDes)
+00051         {
+00052         _LIT(KTextDescOverflow,"Descriptor overflow - maxlength %d\n");
+00053         console->Printf(KTextDescOverflow,aDes.MaxLength());
+00054         }
+00055 
+00056 
+00057 // Do the example
+00058 LOCAL_C void doExampleL()
+00059     {                              
+00060 
+00061         TInt index;
+00062         TInt counter;
+00063 
+00064                                 // Use a TBuf to demonstrate some of these
+00065         TBuf<32> buf(KTextHelloWorld);
+00066                 
+00067                         //                              
+00068                         // Copy(),CopyF(), CopyUC() & CopyCP()  * * * 
+00069                         //
+00070                         // Note that CopyF() CopyUC() & CopyCP() are locale dependent
+00071 
+00072         _LIT(KTitleCopy,"\n--->Copy(),CopyF(),CopyUC() & CopyCP()\n");
+00073         _LIT(KNoteAboutLocale1,"\nNote that the behaviour of CopyF(), CopyUC() & CopyCP() is\n");
+00074         _LIT(KNoteAboutLocale2,"dependent on the locale.\n");
+00075         console->Printf(KTitleCopy);
+00076         console->Printf(KNoteAboutLocale1);
+00077         console->Printf(KNoteAboutLocale2);
+00078                                                 
+00079                                 // Show buf's content,length,size and
+00080                                 // maximum size.
+00081         console->Printf(KFormatBufLen,&buf,buf.Length());
+00082         console->Printf(KFormatSizeMax,buf.Size(),buf.MaxLength());
+00083 
+00084                                 // Copy normal
+00085         buf.Copy(KTextDinner);
+00086 
+00087                                 // Show buf's content,length,size and 
+00088                                 // maximum size.
+00089         console->Printf(KFormatBufLen,&buf,buf.Length());
+00090         console->Printf(KFormatSizeMax,buf.Size(),buf.MaxLength());
+00091         
+00092 
+00093                                 // Copy folded - accents are not preserved
+00094                                 //
+00095                                 // (NB the display may use a different code
+00096                                 // page to that used by the base, in which 
+00097                                 // case the accents will seem to be preserved)
+00098         buf.CopyF(KTextDinner);
+00099                                 
+00100                                 // Show buf's new content,length,size
+00101                                 // and max size
+00102         console->Printf(KFormatBufLen,&buf,buf.Length());
+00103         console->Printf(KFormatSizeMax,buf.Size(),buf.MaxLength());
+00104                                 // Copy uppercase
+00105                                 // Note that accents are preserved.
+00106         buf.CopyUC(KTextDinner);
+00107                                 
+00108                                 // Show buf's new content,length,size
+00109                                 // and maximum size
+00110         console->Printf(KFormatBufLen,&buf,buf.Length());
+00111         console->Printf(KFormatSizeMax,buf.Size(),buf.MaxLength());
+00112 
+00113                                 // Copy capitalised
+00114                                 // Note that accents are preserved.
+00115         _LIT(KTextCatOnMat,"tHe CaT sAt On ThE mAt - voil\205");
+00116         buf.CopyCP(KTextCatOnMat);
+00117                                 
+00118                                 // Show buf's new content,length,size
+00119                                 // and max size
+00120         console->Printf(KFormatBufLen,&buf,buf.Length());
+00121         console->Printf(KFormatSizeMax,buf.Size(),buf.MaxLength());
+00122                                                 
+00123                                 // Length of copied text > 32 causes panic !!
+00124                                 // 
+00125                                 // Remove the "//" marks on the next two lines
+00126                                 // to see this happen
+00127         //_LIT(KTxtCausePanic1,"Panic caused by an attempt to replace text.");
+00128         //buf.Copy(KTxtCausePanic1);
+00129     
+00130                         //
+00131                         // Append() & operator+=  * * * * * * * * * 
+00132                         //
+00133         _LIT(KTitleAppend,"\n--->Append & Operator+=");
+00134         console->Printf(KTitleAppend);
+00135         console->Printf(KPressAnyKeyToContinue);
+00136         console->Getch();
+00137 
+00138                                 // Show buf's content,length,size and
+00139                                 // maximum size.
+00140         buf = KTextHelloWorld;
+00141         console->Printf(KFormatBufLen,&buf,buf.Length());
+00142         console->Printf(KFormatSizeMax,buf.Size(),buf.MaxLength());
+00143 
+00144                                 // Append:
+00145                                 //     1. a single character
+00146                                 //     2. a descriptor
+00147                                 //     3. another descrptor using operator +=
+00148                                 //
+00149                                 // Generates the string
+00150                                 // "Hello World!@XYZ##" in buf
+00151         buf.Append('@');
+00152         buf.Append(KTextXYZ);
+00153         _LIT(KTextHashHash,"##");
+00154         buf += KTextHashHash;
+00155         console->Printf(KFormatBufLen,&buf,buf.Length());
+00156         console->Printf(KFormatSizeMax,buf.Size(),buf.MaxLength());
+00157 
+00158                         //                              
+00159                         // Swap()  * * * * * * * * * * * * * * * 
+00160                         //
+00161         _LIT(KTitleSwap,"\n--->Swap()");
+00162         console->Printf(KTitleSwap);
+00163         console->Printf(KPressAnyKeyToContinue);
+00164         console->Getch();
+00165         
+00166         _LIT(KWhatANiceDay,"What a nice day");
+00167         TBuf<16> altbuf1(KWhatANiceDay);
+00168         buf = KTextHelloWorld;
+00169 
+00170                                 // Show buf and altbuf BEFORE swap
+00171         _LIT(KTextBefore,"          BEFORE...\n");
+00172         console->Printf(KTextBefore);
+00173         console->Printf(KFormatBufLen,&buf,buf.Length());
+00174         console->Printf(KFormatSizeMax,buf.Size(),buf.MaxLength());
+00175         
+00176         console->Printf(KFormatBufLen,&altbuf1,altbuf1.Length());
+00177         console->Printf(KFormatSizeMax,altbuf1.Size(),altbuf1.MaxLength());
+00178         
+00179                                 // now swap the descriptors and look at
+00180                                 // buf and altbuf again;
+00181                                 // The content, length and size of the 
+00182                                 // descriptors have swapped; their maximum 
+00183                                 // lengths have NOT changed.
+00184         buf.Swap(altbuf1);
+00185 
+00186         _LIT(KTextAfter,"          AFTER...\n");
+00187         console->Printf(KTextAfter);
+00188         console->Printf(KFormatBufLen,&buf,buf.Length());
+00189         console->Printf(KFormatSizeMax,buf.Size(),buf.MaxLength());
+00190         
+00191         console->Printf(KFormatBufLen,&altbuf1,altbuf1.Length());
+00192         console->Printf(KFormatSizeMax,altbuf1.Size(),altbuf1.MaxLength()
+00193                                           );
+00194 
+00195                                 // Swap is ok provided the maximum length
+00196                                 // of each descriptor is big enough to 
+00197                                 // hold the other's data.
+00198         
+00199                                 // altbuf2 is too small to accommodate 
+00200                                 // buf's data !!
+00201                                 // 
+00202                                 // Remove the "//" marks on the next three lines
+00203                                 // to see this panic
+00204         //_LIT(KTxtxxx,"xxx");
+00205         //TBuf<8>  altbuf2(KTxtxxx);
+00206         //buf = KTextHelloWorld;
+00207         //buf.Swap(altbuf2);
+00208     
+00209         
+00210                         //                              
+00211                         // Repeat()  * * * * * * * * * * * * * * * 
+00212                         //
+00213         _LIT(KTitleRepeat,"\n--->Repeat()");
+00214         console->Printf(KTitleRepeat);
+00215         console->Printf(KPressAnyKeyToContinue);
+00216         console->Getch();
+00217 
+00218                                 // Set current length of buf to 16 and
+00219                                 // copy repeat the characters "Hello".
+00220                                 // The descriptor is filled up to 
+00221                                 // its CURRENT LENGTH.
+00222                                 // Result is the 16 charcters
+00223                                 // "HelloHelloHelloH"
+00224                                 //
+00225                                 // Note the truncation. 
+00226         buf.SetLength(16);
+00227         buf.Repeat(KTextHello);
+00228 
+00229                                 // Look at it.
+00230         console->Printf(KFormatBufLen,&buf,buf.Length());
+00231         console->Printf(KFormatSizeMax,buf.Size(),buf.MaxLength());
+00232 
+00233                                 // Now set the length to 8 characters
+00234                                 // and do Repeat again.
+00235                                 // Result is the 8 characters
+00236                                 // "HelloHel"
+00237 
+00238         buf.SetLength(8);
+00239         buf.Repeat(KTextHello);
+00240 
+00241                                 // Look at it
+00242         console->Printf(KFormatBufLen,&buf,buf.Length());
+00243         console->Printf(KFormatSizeMax,buf.Size(),buf.MaxLength());
+00244         
+00245                         //                              
+00246                         // Insert() & Delete()  * * * * * * * * *
+00247                         //
+00248         _LIT(KTitleInsert,"\n--->Insert() & Delete()");
+00249         console->Printf(KTitleInsert);
+00250         console->Printf(KPressAnyKeyToContinue);
+00251         console->Getch();
+00252 
+00253                                 // set buf to contain the text "abc" and 
+00254                                 // look at it
+00255         _LIT(KTextAbc,"abc");
+00256         buf = KTextAbc;
+00257         console->Printf(KFormatBufLenSizeMax,
+00258                                         &buf,
+00259                                         buf.Length(),
+00260                                         buf.Size(),
+00261                                         buf.MaxLength()
+00262                                    );
+00263 
+00264                                 // Insert the descriptor at the beginning
+00265                                 // of buf to give "XYZabc"
+00266                                 //
+00267         
+00268         buf.Insert(0,KTextXYZ);
+00269 
+00270                                 // Look at it
+00271         console->Printf(KFormatBufLenSizeMax,
+00272                                         &buf,
+00273                                         buf.Length(),
+00274                                         buf.Size(),
+00275                                         buf.MaxLength()
+00276                                    );
+00277         
+00278                                 // Now insert another descriptor at pos 2
+00279                                 // to give "XijklmnYZabc"
+00280                                 //
+00281         _LIT(KTextijklmn,"ijklmn");
+00282         buf.Insert(1,KTextijklmn);
+00283 
+00284                                 // Show result
+00285         console->Printf(KFormatBufLenSizeMax,
+00286                                         &buf,
+00287                                         buf.Length(),
+00288                                         buf.Size(),
+00289                                         buf.MaxLength()
+00290                                    );
+00291                                                                         
+00292         
+00293                                 // Insertion point out of range
+00294                                 // (> current length of descriptor)
+00295                                 // 
+00296                                 // Remove the "//" marks on the next line
+00297                                 // to see this panic
+00298         //_LIT(KTxtqwerty,"qwerty");
+00299         //buf.Insert(buf.Length()+1,KTxtqwerty);
+00300         
+00301         
+00302                                 // Resulting length of data
+00303                                 // is > maximum length.
+00304                                 // 
+00305                                 // Remove the "//" marks on the next line
+00306                                 // to see this panic
+00307         //_LIT(KTxtatoz,"abcdefghijklmnopqrstuvwxyz");
+00308         //buf.Insert(12,KTxtatoz);
+00309         
+00310         
+00311                                 // Now delete the 3 data 
+00312                                 // items (characters) at the start
+00313                                 // of buf to give "klmnYZabc"
+00314         buf.Delete(0,3);
+00315 
+00316                                 // Show result
+00317         console->Printf(KFormatBufLenSizeMax,
+00318                                         &buf,
+00319                                         buf.Length(),
+00320                                         buf.Size(),
+00321                                         buf.MaxLength()
+00322                                    );
+00323         
+00324                                 // Now delete the 4 data items (characters) at
+00325                                 // position 4 to give "klmnc"
+00326                                 //
+00327         buf.Delete(4,4);
+00328         
+00329                                 // Show result
+00330         console->Printf(KFormatBufLenSizeMax,
+00331                                         &buf,
+00332                                         buf.Length(),
+00333                                         buf.Size(),
+00334                                         buf.MaxLength()
+00335                                    );
+00336         
+00337                                 // An excessive length for deletion is 
+00338                                 // truncated to a sensible value. Deletes 
+00339                                 // all the data starting at pos 1 to 
+00340                                 // give "k"
+00341                                 // (Note that the length actually
+00342                                 //  deleted is 4 NOT 25000).
+00343                                                         
+00344         buf.Delete(1,25000);
+00345         
+00346                                 // Show result
+00347         console->Printf(KFormatBufLenSizeMax,
+00348                                     &buf,
+00349                                     buf.Length(),
+00350                                     buf.Size(),
+00351                                     buf.MaxLength()
+00352                                    );
+00353                  
+00354                         //                              
+00355                         // TrimLeft() & TrimRight()  * * * * * * * * *
+00356                         //
+00357         _LIT(KTitleTrimLeft,"\n--->TrimLeft() & TrimRight()");
+00358         console->Printf(KTitleTrimLeft);
+00359         console->Printf(KPressAnyKeyToContinue);
+00360         console->Getch();
+00361 
+00362                                 // set buf up and show the detail
+00363         buf.Fill(' ',18);
+00364         buf.Replace(3,(&KTextHelloWorld)->Length(),KTextHelloWorld);
+00365         console->Printf(KFormatBufLenSizeMax,  
+00366                         &buf,
+00367                                         buf.Length(),
+00368                                         buf.Size(),
+00369                                         buf.MaxLength()
+00370                                    );
+00371 
+00372                                 // Remove left hand spaces      
+00373         buf.TrimLeft(); 
+00374         console->Printf(KFormatBufLenSizeMax,  
+00375                         &buf,
+00376                                         buf.Length(),
+00377                                         buf.Size(),
+00378                                         buf.MaxLength()
+00379                                    );
+00380 
+00381                                 // Remove right hand spaces     
+00382         buf.TrimRight();        
+00383         console->Printf(KFormatBufLenSizeMax,  
+00384                         &buf,
+00385                                         buf.Length(),
+00386                                         buf.Size(),
+00387                                         buf.MaxLength()
+00388                                    );
+00389 
+00390                                 // Trim() removes both left and right
+00391                                 // hand spaces 
+00392 
+00393                  
+00394                         //                              
+00395                         // FillZ() & Fill()  * * * * * * * * * *  
+00396                         //
+00397         _LIT(KTitleFill,"\n--->FillZ() & Fill()");
+00398         console->Printf(KTitleFill);
+00399         console->Printf(KPressAnyKeyToContinue);
+00400         console->Getch();
+00401                             
+00402                                 // Set current length of buf
+00403                                 // Fillz() fills buf up to its current length
+00404                                 // with 0x00.
+00405         buf.SetLength(8);
+00406         buf.FillZ();
+00407 
+00408                                 // Show it
+00409         counter = buf.Length();
+00410         for (index = 0; index < counter; index++)
+00411                 console->Printf(KFormatCommon,buf[index]);
+00412                 
+00413         console->Printf(KFormatLenSizeMax,
+00414                             buf.Length(),
+00415                                         buf.Size(),
+00416                                         buf.MaxLength()
+00417                                    );
+00418 
+00419                                 // Fills buf up to its current length 
+00420                                 // with 'A'
+00421         buf.Fill('A');
+00422         
+00423                                 // show it
+00424         console->Printf(KFormatBufLenSizeMax,  
+00425                         &buf,
+00426                                         buf.Length(),
+00427                                         buf.Size(),
+00428                                         buf.MaxLength()
+00429                                    );
+00430         
+00431                         //                              
+00432                         // Num(), NumUC(), AppendNum() & AppendNumUC()
+00433                         //
+00434         _LIT(KTitleNum,"\n--->Num(), NumUC(), AppendNum()");
+00435         console->Printf(KTitleNum);
+00436         console->Printf(KPressAnyKeyToContinue);
+00437         console->Getch();
+00438 
+00439                                 // convert a signed integer to 
+00440                                 // decimal characters
+00441         buf.Num(-176);
+00442 
+00443                                 // show it
+00444         console->Printf(KFormatBufLenSizeMax,  
+00445                         &buf,
+00446                                         buf.Length(),
+00447                                         buf.Size(),
+00448                                         buf.MaxLength()
+00449                                    );
+00450 
+00451                                 // convert another signed integer
+00452         buf.Num(12345);
+00453 
+00454                                 // show it
+00455         console->Printf(KFormatBufLenSizeMax,  
+00456                         &buf,
+00457                                     buf.Length(),
+00458                                         buf.Size(),
+00459                                         buf.MaxLength()
+00460                                    );
+00461 
+00462                                 // convert an unsigned integer
+00463         TUint nosign = 176;
+00464         
+00465                                 // ... into decimal characters (the default,
+00466                                 // if not explicitly specified)
+00467         buf.Num(nosign);
+00468         console->Printf(KFormatBufLenSizeMax,  
+00469                         &buf,
+00470                                     buf.Length(),
+00471                                         buf.Size(),
+00472                                         buf.MaxLength()
+00473                                    );
+00474                                         
+00475                                 // ... into binary characters
+00476         buf.Num(nosign,EBinary);
+00477         console->Printf(KFormatBufLenSizeMax,  
+00478                         &buf,
+00479                                         buf.Length(),
+00480                                         buf.Size(),
+00481                                         buf.MaxLength()
+00482                                    );
+00483         
+00484                                 // ... into octal characters
+00485         buf.Num(nosign,EOctal);
+00486         console->Printf(KFormatBufLenSizeMax,  
+00487                         &buf,
+00488                                         buf.Length(),
+00489                                         buf.Size(),
+00490                                         buf.MaxLength()
+00491                                    );
+00492         
+00493                                 // ... into lower case hex characters
+00494         buf.Num(nosign,EHex);
+00495         console->Printf(KFormatBufLenSizeMax,  
+00496                         &buf,
+00497                                         buf.Length(),
+00498                                         buf.Size(),
+00499                                         buf.MaxLength()
+00500                                    );                             
+00501         
+00502                                 // ... into upper case hex characters
+00503         buf.NumUC(nosign,EHex);
+00504         console->Printf(KFormatBufLenSizeMax,  
+00505                         &buf,
+00506                                     buf.Length(),
+00507                                     buf.Size(),
+00508                                     buf.MaxLength()
+00509                                    );
+00510                         
+00511                                 // Append functions the same, except 
+00512                                 // they append the converted data.
+00513                                 // Put "xyz" into the descriptor, convert
+00514                                 // and concatenate the variations.
+00515 
+00516         _LIT(KTextxyz,"xyz");                           
+00517         buf = KTextxyz;
+00518 
+00519         buf.AppendNum(nosign);
+00520         buf.AppendNum(nosign,EBinary);
+00521         buf.AppendNum(nosign,EOctal);
+00522         buf.AppendNum(nosign,EHex);
+00523         buf.AppendNumUC(nosign,EHex);
+00524         console->Printf(KFormatBufLenSizeMax,  
+00525                         &buf,
+00526                                         buf.Length(),
+00527                                         buf.Size(),
+00528                                         buf.MaxLength()
+00529                                    );
+00530                                                 
+00531                         //                              
+00532                         // Justify() & AppendJustify()* * * 
+00533                         //
+00534         _LIT(KTitleJustify,"\n--->Justify() & AppendJustify()");
+00535         console->Printf(KTitleJustify);
+00536         console->Printf(KPressAnyKeyToContinue);
+00537         
+00538         console->Getch();
+00539 
+00540                                 // source descriptor for this example has
+00541                                 // length 12. 
+00542         TBufC<40> src(KTextHelloWorld);
+00543                                 
+00544                                 // target field in buf has width 16 (NB this
+00545                                 // is greater than the length of the descriptor 
+00546                                 // src).
+00547                                 // src is copied into target field, aligned left 
+00548                                 // and padded with '@' characters.
+00549                                 //
+00550                                 // length of buf becomes the same as the 
+00551                                 // specified width, i.e 16 
+00552         buf.Justify(src,16,ELeft,'@');
+00553         console->Printf(KFormatBufLenSizeMax,  
+00554                         &buf,
+00555                                         buf.Length(),
+00556                                         buf.Size(),
+00557                                         buf.MaxLength()
+00558                                    );
+00559         
+00560                                 // target field in buf has width 16 (NB this
+00561                                 // is greater than the length of the descriptor
+00562                                 // src).
+00563                                 // src is copied into target field, aligned centre 
+00564                                 // and padded with '@' characters
+00565                                 //
+00566                                 // length of buf becomes the same as the
+00567                                 // specified width, i.e 16 
+00568         buf.Justify(src,16,ECenter,'@');
+00569         console->Printf(KFormatBufLenSizeMax,  
+00570                         &buf,
+00571                                         buf.Length(),
+00572                                         buf.Size(),
+00573                                         buf.MaxLength()
+00574                                    );
+00575         
+00576                                 // target field in buf has width 10 (NB this
+00577                                 // is smaller than the length of the descriptor
+00578                                 // src).
+00579                                 // src is copied into target field but truncated
+00580                                 // to 10 characters and, therefore, alignment and 
+00581                                 // padding information not used.
+00582                                 //
+00583                                 // length of buf becomes the same as the 
+00584                                 // width, i.e 10 
+00585         buf.Justify(src,10,ECenter,'@');
+00586         console->Printf(KFormatBufLenSizeMax,  
+00587                         &buf,
+00588                                         buf.Length(),
+00589                                         buf.Size(),
+00590                                         buf.MaxLength()
+00591                                    );
+00592                 
+00593                                 // target field in buf is set to the length of
+00594                                 // the descriptor src (whatever it currently is)
+00595                                 //
+00596                                 // src copied into target field. No padding and
+00597                                 // no truncatiuon needed and so the
+00598                                 // alignment and padding information is not used.
+00599                                 //
+00600                                 // length of buf becomes the same as the length
+00601                                 // of src i.e 12 
+00602         buf.Justify(src,KDefaultJustifyWidth,ECenter,'@');
+00603         console->Printf(KFormatBufLenSizeMax,  
+00604                         &buf,
+00605                                         buf.Length(),
+00606                                         buf.Size(),
+00607                                         buf.MaxLength()
+00608                                    );
+00609         
+00610         
+00611         
+00612                                 // implied width > maximum length of buf.
+00613                                 // 
+00614                                 // Remove the "//" marks on the next two lines
+00615                                 // to see this panic
+00616         //_LIT(KTxtPanicCausingText,"Panic causing text because length > 32");
+00617         //src = KTxtPanicCausingText;
+00618         //buf.Justify(src,KDefaultJustifyWidth,ECenter,'@' );
+00619         
+00620 
+00621          
+00622                                 // explicit width > maximum length of buf
+00623                                 // 
+00624                                 // Remove the "//" marks on the next line
+00625                                 // to see this panic
+00626         //buf.Justify(src,33,ECenter,'@');
+00627         
+00628 
+00629                                 // AppendJustify() is  similar but target 
+00630                                 // field appended to descriptor.
+00631                                 //
+00632                                 // Target field in buf has width 16 
+00633                                 // (NB greater than length of descriptor 
+00634                                 // src) and is appended to existing content
+00635                                 // of buf.
+00636                                 // src copied into target field, 
+00637                                 // aligned left and padded with '@' 
+00638                                 // characters
+00639                                 //
+00640                                 // Resulting length of buf is the length
+00641                                 // of "ABCD" plus the width of the target
+00642                                 // field (16) giving a value of 20.
+00643         _LIT(KTextABCD,"ABCD");
+00644         buf = KTextABCD;
+00645         buf.AppendJustify(src,16,ELeft,'@');
+00646         console->Printf(KFormatBufLenSizeMax,  
+00647                         &buf,
+00648                                         buf.Length(),
+00649                                         buf.Size(),
+00650                                         buf.MaxLength()
+00651                                    );
+00652 
+00653                         //                              
+00654                         // Format() & AppendFormat() * * * 
+00655                         //
+00656         _LIT(KTitleFormatAndAppendFormat,"\n--->Format() & AppendFormat()");
+00657         console->Printf(KTitleFormatAndAppendFormat);
+00658         console->Printf(KPressAnyKeyToContinue);
+00659         console->Getch();
+00660 
+00661                                 // use tgt as a target descriptor to show 
+00662                                 // the results of format()
+00663         TBuf<128> tgt;
+00664         
+00665                                 // The basic %<type> format.
+00666                                 // Interprets the arguments as signed/unsigned
+00667                                 // integers and generates the appropriate
+00668                                 // character representations. The characters only
+00669                                 // occupy the space needed to represent them.
+00670                                 //
+00671                                 // Generates:"1000001 A 65 101 65 41"
+00672                                 //
+00673                                 // format string is:
+00674                                 // "%b %c %d %o %u %x"
+00675 
+00676         _LIT(KFormat1,"%b %c %d %o %u %x");
+00677         tgt.Format(KFormat1,65,65,65,65,65,65);
+00678     console->Printf(KFormatBufLenSizeMax,  
+00679                         &tgt,
+00680                                         tgt.Length(),
+00681                                         tgt.Size(),
+00682                                         tgt.MaxLength()
+00683                                    );                   
+00684 
+00685                                 // Interprets the argument as an unsigned
+00686                                 // integer; the generated (hex) characters are
+00687                                 // right aligned and padded to the left
+00688                                 // with '0' to make a total of 4 characters.
+00689                                 //
+00690                         // Generates:"0041"
+00691                                 //
+00692                                 // format string is:
+00693                                 // "%04x"
+00694         _LIT(KFormat2,"%04x");
+00695         tgt.Format(KFormat2,65);
+00696     console->Printf(KFormatBufLenSizeMax,  
+00697                         &tgt,
+00698                                         tgt.Length(),
+00699                                         tgt.Size(),
+00700                                         tgt.MaxLength()
+00701                                    );
+00702                                                                                 
+00703                                 // Interprets the argument as an unsigned
+00704                                 // integer;the generated (hex) characters are
+00705                                 // right aligned and padded to the left with 
+00706                                 // blanks to make a total of 4 characters.
+00707                                 //
+00708                         // Generates:"  41"
+00709                                 //
+00710                                 // format string is:
+00711                                 // "%4x"
+00712         tgt.Format(KFormatfourex,65);
+00713     console->Printf(KFormatBufLenSizeMax,  
+00714                         &tgt,
+00715                                         tgt.Length(),
+00716                                         tgt.Size(),
+00717                                         tgt.MaxLength()
+00718                                    );                   
+00719                                                                                 
+00720                                 // Interprets the argument as an unsigned
+00721                                 // integer; the generated (hex) characters are
+00722                                 // right aligned and padded to the left with 
+00723                                 // blanks to make a total of 4 characters.
+00724                                 //
+00725                         // Generates:"1fff" 
+00726                                 //
+00727                                 // NB the correct hex value is "1ffff"
+00728                                 // but width specified as 4 resulting 
+00729                                 // in TRUNCATION.
+00730                                 // 
+00731                                 //
+00732                                 // format string is:
+00733                                 // "%4x"
+00734         tgt.Format(KFormatfourex,131071);
+00735     console->Printf(KFormatBufLenSizeMax,  
+00736                         &tgt,
+00737                                         tgt.Length(),
+00738                                         tgt.Size(),
+00739                                         tgt.MaxLength()
+00740                                    );                                                                                   
+00741         
+00742                                 // The '*' means that the width of the output
+00743                                 // is taken from the 1st argument in the list; 
+00744                                 // Interprets the 2nd argument as an unsigned
+00745                                 // integer.
+00746                                 // The generated (hex) characters are right 
+00747                                 // aligned and padded to the left with blanks
+00748                                 // to make a total of 4 characters.
+00749                                 //
+00750                         // Generates:"  41"
+00751                                 //
+00752                                 // format string is:
+00753                                 // "%*x"
+00754         _LIT(KFormat4,"%*x");
+00755         tgt.Format(KFormat4,4,65);
+00756     console->Printf(KFormatBufLenSizeMax,  
+00757                         &tgt,
+00758                                     tgt.Length(),
+00759                                     tgt.Size(),
+00760                                     tgt.MaxLength()
+00761                                    );                   
+00762                 
+00763                                 // Interprets the 1st argument as a signed
+00764                                 // integer. 
+00765                                 //
+00766                                 // The generated (decimal) characters are 
+00767                                 // right aligned and padded to the left 
+00768                                 // with '$' to make a total of 4 characters.
+00769                                 //
+00770                                 // These are then followed by the
+00771                                 // 4 characters ".00 "
+00772                                 //                                                                                         
+00773                                 // Interprets the 2nd argument as a descriptor.
+00774                                 // The characters within the descriptor are
+00775                                 // appended to those already generated.
+00776                                 //
+00777                         // Generates:"$$65.00 over"
+00778                                 //
+00779                                 // Format string is:
+00780                                 // "%+$4d.00 %S"
+00781                                 //
+00782     
+00783         _LIT(KTextover,"over");
+00784         _LIT(KFormat5,"%+$4d.00 %S");
+00785         tgt.Format(KFormat5,65,&KTextover);
+00786     console->Printf(KFormatBufLenSizeMax,  
+00787                         &tgt,
+00788                                         tgt.Length(),
+00789                                         tgt.Size(),
+00790                                         tgt.MaxLength()
+00791                                    );
+00792         
+00793         
+00794                                 // The * means that the width of the 
+00795                                 // output is taken from the 1st argument 
+00796                                 // in the list.
+00797                                 //
+00798                                 // Interprets the 2nd argument as a descriptor.
+00799                                 // The characters copied from it are right 
+00800                                 // aligned and padded on the left with
+00801                                 // '0' characters
+00802                                 //
+00803                         // Generates:"000000fred"
+00804                                 //
+00805                                 // Format string is:
+00806                                 // "%+0*S"
+00807                                 //
+00808         
+00809         _LIT(KTextfred,"fred");
+00810         _LIT(KFormat6,"%+0*S");
+00811         tgt.Format(KFormat6,10,&KTextfred);
+00812     console->Printf(KFormatBufLenSizeMax,  
+00813                         &tgt,
+00814                                         tgt.Length(),
+00815                                         tgt.Size(),
+00816                                         tgt.MaxLength()
+00817                                    );                          
+00818     
+00819 
+00820                                 // The * means that the fill character is 
+00821                                 // taken from the 1st argument in the list.
+00822                                 //
+00823                                 // Interprets the 2nd argument as an unsigned
+00824                                 // integer.
+00825                                 // The generated characters are centrally 
+00826                                 // aligned and padded on the left and right
+00827                                 // with '*' to make 6 characters.
+00828                                 //
+00829                         // Generates:"**41**"
+00830                                 //
+00831                                 // Format string is:
+00832                                 // "%=*6x"
+00833                                 //
+00834         
+00835         _LIT(KFormat7,"%=*6x");
+00836         tgt.Format(KFormat7,'*',65);
+00837     console->Printf(KFormatBufLenSizeMax,  
+00838                         &tgt,
+00839                                         tgt.Length(),
+00840                                         tgt.Size(),
+00841                                         tgt.MaxLength()
+00842                                    );
+00843                                                                     
+00844                                 // The 1st '*' means that the fill character 
+00845                                 // is taken from the 1st argument in the list.
+00846                                 //
+00847                                 // The 2nd '*' means that the width is taken
+00848                                 // from the 2nd argument in the list
+00849                                 //
+00850                                 // Interprets the 3rd argument as a signed
+00851                                 // integer.
+00852                                 // The generated characters are right aligned
+00853                                 // and padded on the left with '.' to make
+00854                                 // 10 characters.
+00855                                 //
+00856                         // Generates:".......-65"
+00857                                 //
+00858                                 // Format string is:
+00859                                 // "%+**d"
+00860                                 //
+00861                 
+00862         _LIT(KFormat8,"%+**d");
+00863         tgt.Format(KFormat8,'.',10,(-65));
+00864     console->Printf(KFormatBufLenSizeMax,  
+00865                         &tgt,
+00866                                     tgt.Length(),
+00867                                         tgt.Size(),
+00868                                         tgt.MaxLength()
+00869                                    );
+00870                                                                    
+00871                 // Same as the previous example but the 
+00872                 // characters are left aligned and padded to
+00873                 // the right with '.' characters.
+00874                                 //
+00875                         // Generates:"-65......."              
+00876                                 //
+00877                                 // Format string is:
+00878                                 // "%-**d"
+00879                                 //
+00880         
+00881         _LIT(KFormat9,"%-**d");     
+00882         tgt.Format(KFormat9,'.',10,(-65));
+00883     console->Printf(KFormatBufLenSizeMax,  
+00884                         &tgt,
+00885                                         tgt.Length(),
+00886                                         tgt.Size(),
+00887                                         tgt.MaxLength()
+00888                                    );                                                  
+00889                               
+00890                 // Generates 6 fill characters 'A'.
+00891                 // Makes no use of the argument list.
+00892                 //
+00893                 // Generates: "AAAAAA"                
+00894                                 //
+00895                                 // Format string is:
+00896                                 // "%-A6p"
+00897                                 //
+00898         
+00899         _LIT(KFormat10,"%-A6p");            
+00900         tgt.Format(KFormat10,65);
+00901         console->Printf(KFormatBufLenSizeMax,  
+00902                         &tgt,
+00903                                         tgt.Length(),
+00904                                         tgt.Size(),
+00905                                         tgt.MaxLength()
+00906                                    );
+00907 
+00908                  // Interpret the argument as a TInt64 type.        
+00909         _LIT(KFormat10a,"%Li");  
+00910         
+00911         TInt64   var(65);
+00912         tgt.Format(KFormat10a,var);
+00913         
+00914         console->Printf(KFormatBufLenSizeMax,  
+00915                         &tgt,
+00916                                         tgt.Length(),
+00917                                         tgt.Size(),
+00918                                         tgt.MaxLength()
+00919                            );
+00920             
+00921 
+00922 
+00923 
+00924                                 // Interpret the argument as an unsigned integer
+00925                                 // and convert to a two byte numeric 
+00926                                 // representation (most significant byte first)
+00927                                 //
+00928                                 // So 4660 = 0x1234 => 1st byte contains 0x12
+00929                                 //                     2nd byte contains 0x34 
+00930                                 //
+00931                                 // NB This is same for both ASCII & UNICODE build
+00932                                 //
+00933                                 // Format string is:
+00934                                 // "%m"
+00935                                 //
+00936          
+00937         _LIT(KFormat11,"%m");
+00938         tgt.Format(KFormat11,4660);
+00939         
+00940         counter = tgt.Length();
+00941         for (index = 0; index < counter; index++)
+00942                 console->Printf(KFormatCommon,tgt[index]);
+00943                 
+00944         console->Printf(KFormatLenSizeMax,
+00945                                         tgt.Length(),
+00946                                         tgt.Size(),
+00947                                         tgt.MaxLength()
+00948                                    );
+00949 
+00950 
+00951 
+00952 
+00953 
+00954                                 // Interpret the argument as an unsigned integer
+00955                                 // and convert to a four byte numeric 
+00956                                 // representation (most significant byte first)
+00957                                 //
+00958                                 // So 4660 = 0x1234 => 1st byte contains 0x00
+00959                                 //                     2nd byte contains 0x00 
+00960                                 //                                         3rd byte contains 0x12
+00961                                 //                     4th byte contains 0x34
+00962                                 // NB This is same for both ASCII & UNICODE build         
+00963                                 //
+00964                                 // Format string is:
+00965                                 // "%M"
+00966                                 //
+00967         
+00968         _LIT(KFormat12,"%M");
+00969         tgt.Format(KFormat12,4660);                                                
+00970         
+00971         counter = tgt.Length(); 
+00972     for (index = 0; index < counter; index++)
+00973                 console->Printf(KFormatCommon,tgt[index]);
+00974                 
+00975         console->Printf(KFormatLenSizeMax,
+00976                                         tgt.Length(),
+00977                                         tgt.Size(),
+00978                                         tgt.MaxLength()
+00979                                    );
+00980 
+00981                                 // Interpret the argument as an unsigned integer
+00982                                 // and convert to a two byte numeric 
+00983                                 // representation (least significant byte first)
+00984                                 //
+00985                                 // So 4660 = 0x1234 => 1st byte contains 0x34
+00986                                 //                     2nd byte contains 0x12 
+00987                                 //
+00988                                 // NB This is same for both ASCII & UNICODE build
+00989                                 //
+00990                                 // Format string is:
+00991                                 // "%w"
+00992                                 //
+00993       
+00994         _LIT(KFormat13,"%w");
+00995         tgt.Format(KFormat13,4660);
+00996         
+00997         counter = tgt.Length();
+00998     for (index = 0; index < counter; index++)
+00999                 console->Printf(KFormatCommon,tgt[index]);
+01000                 
+01001         console->Printf(KFormatLenSizeMax,
+01002                                         tgt.Length(),
+01003                                         tgt.Size(),
+01004                                         tgt.MaxLength()
+01005                                    );
+01006 
+01007                                 // Interpret the argument as an unsigned integer
+01008                                 // and convert to a four byte numeric 
+01009                                 // representation (least significant byte first)
+01010                                 //
+01011                                 // So 4660 = 0x1234 => 1st byte contains 0x34
+01012                                 //                     2nd byte contains 0x12 
+01013                                 //                                         3rd byte contains 0x00
+01014                                 //                     4th byte contains 0x00
+01015                                 // NB This is same for both ASCII & UNICODE build         
+01016                                 //
+01017                                 // Format string is:
+01018                                 // "%W"
+01019                                 //
+01020 
+01021         _LIT(KFormat14,"%W");
+01022         tgt.Format(KFormat14,4660);                                                
+01023         
+01024         counter = tgt.Length(); 
+01025     for (index = 0; index < counter; index++)
+01026                 console->Printf(KFormatCommon,tgt[index]);
+01027                 
+01028         console->Printf(KFormatLenSizeMax,
+01029                                         tgt.Length(),
+01030                                         tgt.Size(),
+01031                                         tgt.MaxLength()
+01032                                    );
+01033         
+01034         console->Printf(KPressAnyKeyToContinue);
+01035         console->Getch();
+01036         
+01037         
+01038                         //                              
+01039                         // AppendFormat() illustrating use of the
+01040                         // overflow handler 
+01041                         //
+01042         _LIT(KTitleOverflowHandler,"\n--->AppendFormat() & the overflow handler");
+01043         console->Printf(KTitleOverflowHandler);
+01044         console->Printf(KPressAnyKeyToContinue);
+01045         console->Getch();
+01046 
+01047                                 // use the TestOverflow class as the overflow 
+01048                                 // handler
+01049         TBuf<16>     overtgt;
+01050         TestOverflow theoverflow;
+01051         
+01052                                 // prime "overtgt" with data (of length 14)
+01053         _LIT(KTextabcdefghijklmn,"abcdefghijklmn");
+01054         overtgt = KTextabcdefghijklmn;
+01055 
+01056                                 // Format string contains just literal
+01057                                 // text and no embedded commands.
+01058                                 // Length of literal text is 3
+01059                                 // 14+3 > max length of "overtgt" and 
+01060                                 // so theoverflow.Overflow() will be invoked
+01061         
+01062         _LIT(KTextopq,"opq");
+01063         overtgt.AppendFormat(KTextopq,&theoverflow);
+01064 
+01065                                 // NB omitting the 2nd parameter, giving:
+01066                                 // overtgt.AppendFormat(KTextopq);
+01067                                 // results in a panic.
+01068     }
+01069         
+01070 
+01071 
+01072 
+01073 
+01074 
+01075 
+01076         
+01077         
+