inc/FBaseUtilScanner.h

   1 //
   2 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   3 //
   4 // Licensed under the Apache License, Version 2.0 (the License);
   5 // you may not use this file except in compliance with the License.
   6 // You may obtain a copy of the License at
   7 //
   8 //     http://www.apache.org/licenses/LICENSE-2.0
   9 //
  10 // Unless required by applicable law or agreed to in writing, software
  11 // distributed under the License is distributed on an "AS IS" BASIS,
  12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 // See the License for the specific language governing permissions and
  14 // limitations under the License.
  15 //
  16
  17
  18 /**
  19  * @file        FBaseUtilScanner.h
  20  * @brief       This is the header file for the %Scanner class.
  21  *
  22  * This header file contains declarations and definitions of the %Scanner class.
  23  *
  24  */
  25
  26 #ifndef _FBASE_UTIL_SCANNER_H_
  27 #define _FBASE_UTIL_SCANNER_H_
  28
  29 #include <FBaseString.h>
  30 #include <FBaseUtilRegularExpression.h>
  31
  32 namespace Tizen { namespace Base { namespace Utility
  33 {
  34 /**
  35  * @class       Scanner
  36  * @brief       This class provides methods to parse primitive types and strings, and supports the use of regular expressions and various encoding schemes.
  37  * @since 2.1
  38  *
  39  * The %Scanner class breaks the input, which can either be a String instance or strings from a file, into tokens using a delimiter.
  40  * The delimiter is set to whitespace as a default value. The resulting tokens are converted into values of different types according
  41  * to the methods in %Scanner.
  42  *
  43  * The following example demonstrates how to use the %Scanner class.
  44  * @code
  45  *
  46  *      String str = L"1 12 34.5 58 false";
  47  *      Scanner scan;
  48  *      bool ret = false;
  49  *
  50  *      scan.Construct(str);
  51  *
  52  *      ret = scan.IsNextTokenConvertibleToSignedChar();        //ret true
  53  *      signed char val;
  54  *      scan.GetNextSignedChar(val);    //val 1
  55  *
  56  *      ret = scan.IsNextTokenConvertibleToShort(10);   //ret true
  57  *      short shortVal;
  58  *      scan.GetNextShort(shortVal);    //shortVal 12
  59  *
  60  *      ret = scan.IsNextTokenConvertibleToInt(10);     //ret false
  61  *      ret = scan.IsNextTokenConvertibleToFloat();     //ret true
  62  *      float floatVal;
  63  *      scan.GetNextFloat(floatVal);    //floatVal 34.5
  64  *
  65  *      ret = scan.IsNextTokenConvertibleToInt(16);     //ret true
  66  *      int intVal;
  67  *      scan.GetNextInt(intVal, 16);    //intVal 88
  68  *
  69  *      ret = scan.IsNextTokenConvertibleToBool();      //ret true
  70  *      scan.GetNextBool(ret);  //ret false
  71  *
  72  * @endcode
  73  */
  74 class _OSP_EXPORT_ Scanner
  75         : public Tizen::Base::Object
  76 {
  77
  78 public:
  79         /**
  80         * The object is not fully constructed after this constructor is called. @n
  81         * For full construction, the Construct() method must be called right after calling this constructor.
  82         *
  83         * @since 2.1
  84         */
  85         Scanner(void);
  86
  87         /**
  88         * This destructor overrides Tizen::Base::Object::~Object().
  89         *
  90         * @since 2.1
  91         */
  92         virtual ~Scanner(void);
  93
  94         /**
  95         * Initializes the current instance of %Scanner with the specified instance of String.
  96         *
  97         * @since 2.1
  98         * @return       An error code
  99         * @param[in]    inputStr         The string to scan
 100         * @exception    E_SUCCESS        The method is successful.
 101         * @exception    E_INVALID_ARG    The length of the specified @c string is @c 0.
 102         */
 103         result Construct(const String& inputStr);
 104
 105         /**
 106         * Initializes the current instance of %Scanner with a file that includes the strings that are being scanned.
 107         *
 108         * @since 2.1
 109         * @return       An error code
 110         * @param[in]    inputFilePath                   The file to read to construct input data
 111         * @param[in]    encodingScheme                  The encoding type of the file
 112         * @exception    E_SUCCESS                       The method is successful.
 113         * @exception    E_FILE_NOT_FOUND        The input file does not exist.
 114         * @exception    E_IO                                    The file operation is invalid.
 115         * @exception    E_INVALID_ARG                   The specified encoding scheme does not exist.
 116         * @remarks      The supported encoding schemes are ASCII, GSM, UCS-2, UCS-2LE, UCS-2BE, UCS-4, UCS-4LE, UCS-4BE, UTF-8, UTF-16, UTF-16LE, UTF-16BE, UTF-32, UTF-32LE, UTF-32BE, ISO-8859-1~16 (except ISO-8859-12), Windows-874, Windows-1250 ~ Windows-1258, KSC5601, BIG5, GB2312, Shift_JIS, and ISO-2022-jp.
 117         */
 118         result Construct(const String& inputFilePath, const String& encodingScheme);
 119
 120         /**
 121         * Gets the substring of the input data matching the pattern constructed from the specified string. @n
 122         * Delimiter is ignored and the returned string does not include any line terminator.
 123         * If such a pattern in the input data is not found upto the next line terminator, the %FindInLine() method returns an empty string through the out parameter, @c matchedStr.
 124         *
 125         * @since 2.1
 126         * @return       An error code
 127         * @param[in]    patternStr       The string to construct the pattern
 128         * @param[out]   matchedStr       The matched string or empty string
 129         * @exception    E_SUCCESS        The method is successful.
 130         * @exception    E_INVALID_ARG    The length of the specified @c string is @c 0.
 131         * @exception    E_DATA_NOT_FOUND No substring is found in the input data of the current instance.
 132         */
 133         result FindInLine(const String& patternStr, String& matchedStr);
 134
 135         /**
 136         * Gets the substring matching the pattern from the input data. @n
 137         * Delimiter is ignored and the returned string does not include any line terminator.
 138         * If such a pattern in the input data is not found upto the next line terminator, the %FindInLine() method returns an empty string through the out parameter, @c matchedStr.
 139         *
 140         * @since 2.1
 141         * @return       An error code
 142         * @param[in]    pattern                   The pattern to compile for finding the substring from the input data
 143         * @param[out]   matchedStr        The matched string or empty string
 144         * @exception    E_SUCCESS         The method is successful.
 145         * @exception    E_DATA_NOT_FOUND  No substring is found in the input data of the current instance.
 146         */
 147
 148         result FindInLine(const RegularExpression& pattern, String& matchedStr);
 149
 150         /**
 151         * Gets the next token as @c signed @c char. @n The next token is converted to a @c signed @c char using a default radix.
 152         * The @c signed @c char can hold values from -128 to 127.
 153         *
 154         * @since 2.1
 155         * @return       An error code
 156         * @param[out]   nextSignedChar                  The next token as a @c signed @c char
 157         * @exception    E_SUCCESS                       The method is successful.
 158         * @exception    E_NUM_FORMAT                    The next token cannot be translated into a valid signed @c char value.
 159         * @exception    E_DATA_NOT_ENOUGH       There are no tokens remaining for the current instance of %Scanner.
 160         */
 161         result GetNextSignedChar(signed char& nextSignedChar) const;
 162
 163         /**
 164         * Gets the next token as @c signed @c char. @n The next token is converted to a @c signed @c char using the specified @c radix.
 165         * The @c signed @c char can hold values from -128 to 127.
 166         *
 167         * @since 2.1
 168         * @return       An error code
 169         * @param[out]   nextSignedChar                  The next token as a @c signed @c char
 170         * @param[in]    radix                                   The radix to use for conversion
 171         * @exception    E_SUCCESS                       The method is successful.
 172         * @exception    E_NUM_FORMAT                    The next token cannot be translated into a valid @c signed @c char value.
 173         * @exception    E_DATA_NOT_ENOUGH       There are no tokens remaining for the current instance of %Scanner.
 174         */
 175
 176         result GetNextSignedChar(signed char& nextSignedChar, int radix) const;
 177
 178         /**
 179         * Gets the next token as @c int. @n The next token is converted to a @c signed integer using a default radix.
 180         * The @c signed integer can hold values from -2^31 to 2^31-1.
 181         *
 182         * @since 2.1
 183         * @return       An error code
 184         * @param[out]   nextInt                                 The next token as a @c signed integer
 185         * @exception    E_SUCCESS                       The method is successful.
 186         * @exception    E_NUM_FORMAT            The next token cannot be translated into a valid @c signed integer value.
 187         * @exception    E_DATA_NOT_ENOUGH       There are no tokens remaining for the current instance of %Scanner.
 188         */
 189         result GetNextInt(int& nextInt) const;
 190
 191         /**
 192         * Gets the next token as @c int. @n The next token is converted to a @c signed integer using the specified @c radix.
 193         * The @c signed integer can hold values from -2^31 to 2^31-1.
 194         *
 195         * @since 2.1
 196         * @return       An error code
 197         * @param[out]   nextInt                                 The next token as a @c signed integer
 198         * @param[in]    radix                                   The radix to use for conversion
 199         * @exception    E_SUCCESS                       The method is successful.
 200         * @exception    E_NUM_FORMAT                    The next token cannot be translated into a valid @c signed integer value.
 201         * @exception    E_DATA_NOT_ENOUGH       There are no tokens remaining for the current instance of %Scanner.
 202         */
 203         result GetNextInt(int& nextInt, int radix) const;
 204
 205         /**
 206         * Gets the next token as @c short. @n The next token is converted to a @c signed @c short using a default radix.
 207         * The @c signed @c short can hold values from -2^15 to 2^15-1.
 208         *
 209         * @since 2.1
 210         * @return       An error code
 211         * @param[out]   nextShort                       The next token as a signed @c short
 212         * @exception    E_SUCCESS                       The method is successful.
 213         * @exception    E_NUM_FORMAT                    The next token cannot be translated into a valid @c signed @c short value.
 214         * @exception    E_DATA_NOT_ENOUGH       There are no tokens remaining for the current instance of %Scanner.
 215         */
 216         result GetNextShort(short& nextShort) const;
 217
 218         /**
 219         * Gets the next token as @c short. @n The next token is converted to a @c signed @c short using the specified @c radix.
 220         * The @c signed @c short can hold values from -2^15 to 2^15-1.
 221         *
 222         * @since 2.1
 223         * @return       An error code
 224         * @param[out]   nextShort               The next token as a @c signed @c short
 225         * @param[in]    radix                           The radix to use for conversion
 226         * @exception    E_SUCCESS           The method is successful.
 227         * @exception    E_NUM_FORMAT        The next token cannot be translated into a valid @c signed @c short value.
 228         * @exception    E_DATA_NOT_ENOUGH   There are no tokens remaining for the current instance of %Scanner.
 229         */
 230         result GetNextShort(short& nextShort, int radix) const;
 231
 232         /**
 233         * Gets the next token as @c long @c long. @n The next token is converted to a @c signed @c long @c long using a default radix.
 234         * The @c signed @c long @c long can hold values from -2^63 to 2^63-1.
 235         *
 236         * @since 2.1
 237         * @return       An error code
 238         * @param[out]   nextLongLong                    The next token as a @c signed @c long @c long
 239         * @exception    E_SUCCESS                       The method is successful.
 240         * @exception    E_NUM_FORMAT                    The next token cannot be translated into a valid @c signed @c long @c long value.
 241         * @exception    E_DATA_NOT_ENOUGH       There are no tokens remaining for the current instance of %Scanner.
 242         */
 243         result GetNextLongLong(long long& nextLongLong) const;
 244
 245         /**
 246         * Gets the next token as @c long @c long. @n The next token is converted to a @c signed @c long @c long using the specified @c radix.
 247         * The @c signed @c long @c long can hold values from -2^63 to 2^63-1.
 248         *
 249         * @since 2.1
 250         * @return       An error code
 251         * @param[out]   nextLongLong            The next token as a @c signed @c long @c long
 252         * @param[in]    radix                           The radix to use for conversion
 253         * @exception    E_SUCCESS               The method is successful.
 254         * @exception    E_NUM_FORMAT            The next token cannot be translated into a valid @c signed @c long @c long value.
 255         * @exception    E_DATA_NOT_ENOUGH   There are no tokens remaining for the current instance of %Scanner.
 256         */
 257         result GetNextLongLong(long long& nextLongLong, int radix) const;
 258
 259         /**
 260         * Gets the next token as @c float. @n The next token is converted to @c float.
 261         * The @c signed @c float can hold a single-precision 32-bit floating number.
 262         *
 263         * @since 2.1
 264         * @return       An error code
 265         * @param[out]   nextFloat                       The next token as a @c float
 266         * @exception    E_SUCCESS                       The method is successful.
 267         * @exception    E_NUM_FORMAT                    The next token cannot be translated into a valid @c float value.
 268         * @exception    E_DATA_NOT_ENOUGH       There are no tokens remaining for the current instance of %Scanner.
 269         */
 270         result GetNextFloat(float& nextFloat) const;
 271
 272         /**
 273         * Gets the next token as @c double. @n The next token is converted to @c double.
 274         * The signed @c double can hold a double-precision 64-bit floating number.
 275         *
 276         * @since 2.1
 277         * @return       An error code
 278         * @param[out]   nextDouble                      The next token as a @c double
 279         * @exception    E_SUCCESS                       The method is successful.
 280         * @exception    E_NUM_FORMAT                    The next token cannot be translated into a valid @c double value.
 281         * @exception    E_DATA_NOT_ENOUGH       There are no tokens remaining for the current instance of %Scanner.
 282         */
 283         result GetNextDouble(double& nextDouble) const;
 284
 285         /**
 286         * Gets the next token as @c bool. @n The next token is converted to boolean.
 287         * Nothing can be converted, except true/TRUE or false/FALSE.
 288         *
 289         * @since 2.1
 290         * @return       An error code
 291         * @param[out]   nextBool                                The next token as @c bool
 292         * @exception    E_SUCCESS                       The method is successful.
 293         * @exception    E_NUM_FORMAT                    The next token cannot be translated into a valid @c bool value.
 294         * @exception    E_DATA_NOT_ENOUGH       There are no remaining tokens for the current instance of %Scanner.
 295         */
 296         result GetNextBool(bool& nextBool) const;
 297
 298         /**
 299         * Gets the input string up to the next line delimiter and advances the %Scanner to the beginning of the next line. @n
 300         * The returned string does not include any line terminator.
 301         *
 302         * @since 2.1
 303         * @return       An error code
 304         * @param[out]   nextLine                        The next line as an instance of String
 305         * @exception    E_SUCCESS               The method is successful.
 306         * @exception    E_DATA_NOT_ENOUGH   There are no lines remaining for the current instance of %Scanner.
 307         *
 308         * The following example demonstrates how to use the %GetNextLine() method.
 309         *
 310         * @code
 311         *
 312         *       String str = "1 hundred bricks\n2 bricks\n3 hundred bricks\n4 bricks";
 313         *       bool res = false;
 314         *       String out;
 315         *       Scanner scan;
 316         *
 317         *       scan.Construct(str);
 318         *
 319         *       if (scan.HasNextLine())
 320         *       {
 321         *               scan.GetNextLine(out); //returns 1 hundred bricks
 322         *       }
 323         *       else
 324         *       {
 325         *               return;
 326         *       }
 327         *
 328         * @endcode
 329         */
 330         result GetNextLine(String& nextLine) const;
 331
 332         /**
 333         * Gets the next token as String.
 334         *
 335         * @since 2.1
 336         * @return       An error code
 337         * @param[out]   nextTok                         The next token as an instance of String
 338         * @exception    E_SUCCESS               The method is successful.
 339         * @exception    E_DATA_NOT_ENOUGH   There are no tokens remaining for the current instance of %Scanner.
 340         *
 341         * The following example demonstrates how to use the %GetNextToken() method.
 342         * @code
 343         *
 344         *       String str = "1 hundred bricks 2 bricks 3 hundred bricks 4 bricks";
 345         *       bool res =  false;
 346         *       String out;
 347         *       Scanner scan;
 348         *
 349         *       scan.Construct(str);
 350         *       String delimiter(L"\\s*bricks\\s*");
 351         *       scan.SetDelimiter(delimiter);
 352         *
 353         *       if (scan.HasNext())
 354         *       {
 355         *               scan.GetNextToken(out); //returns 1 hundred
 356         *       }
 357         *       else
 358         *       {
 359         *               return;
 360         *       }
 361         *
 362         * @endcode
 363         */
 364         result GetNextToken(String& nextTok) const;
 365
 366         /**
 367         * Gets the next token as String if it matches the pattern constructed from the specified string.
 368         *
 369         * @since 2.1
 370         * @return       An error code
 371         * @param[in]    pattern                         The string from which to construct the pattern
 372         * @param[out]   nextTok                         The next token as an instance of String, @n
 373         *                                               else an empty string if it is does not match
 374         * @exception    E_SUCCESS               The method is successful.
 375         * @exception    E_DATA_NOT_FOUND    The next token does not match the pattern.
 376         * @exception    E_DATA_NOT_ENOUGH   There are no tokens remaining for the current instance of %Scanner.
 377         */
 378         result GetNextToken(const String& pattern, String& nextTok) const;
 379
 380         /**
 381         * Gets the next token as String if it matches the pattern.
 382         *
 383         * @since 2.1
 384         * @return       An error code
 385         * @param[in]    pattern                         The pattern to find
 386         * @param[out]   nextTok                         The next token as an instance of String, @n
 387         *                                               else an empty string if it is does not match
 388         * @exception    E_SUCCESS           The method is successful.
 389         * @exception    E_DATA_NOT_FOUND    The next token does not match the pattern.
 390         * @exception    E_DATA_NOT_ENOUGH   There are no tokens remaining for the current instance of %Scanner.
 391         */
 392         result GetNextToken(const RegularExpression& pattern, String& nextTok) const;
 393
 394         /**
 395         * Gets the radix of this %Scanner.
 396         *
 397         * @since 2.1
 398         * @return       The current radix value
 399         */
 400         int GetRadix(void) const;
 401
 402         /**
 403         * Gets the delimiter of this %Scanner.
 404         *
 405         * @since 2.1
 406         * @return       The current delimiter string
 407         */
 408         String GetDelimiter(void) const;
 409
 410         /**
 411         * Checks whether the current instance of %Scanner has another token.
 412         *
 413         * @since 2.1
 414         * @return       @c true if the current instance has another token, @n
 415         *                               else @c false
 416         */
 417         bool HasNextToken(void) const;
 418
 419         /**
 420         * Checks whether the next token matches the pattern constructed from the specified string.
 421         *
 422         * @since 2.1
 423         * @return       @c true if the next token matches the pattern constructed from the specified string, @n
 424         *                               else @c false
 425         * @param[in]    pattern  The string to construct the pattern
 426         */
 427         bool HasNextToken(const String& pattern) const;
 428
 429         /**
 430         * Checks whether the next token matches the pattern.
 431         *
 432         * @since 2.1
 433         * @return       @c true if the next token matches the pattern, @n
 434         *                               else @c false
 435         * @param[in]    pattern  The pattern to find
 436         */
 437         bool HasNextToken(const RegularExpression& pattern) const;
 438
 439         /**
 440         * Checks whether the next token can be translated into a valid @c signed @c char value in the default radix.
 441         * The @c signed @c char can hold values from -128 to 127.
 442         *
 443         * @since 2.1
 444         * @return       @c true if the next token can be translated into a valid @c signed @c char value in the current radix, @n
 445         *                               else @c false
 446         */
 447         bool IsNextTokenConvertibleToSignedChar(void) const;
 448
 449         /**
 450         * Checks whether the next token can be translated into a valid @c signed @c char value in the specified @c radix.
 451         * The @c signed @c char can hold values from -128 to 127.
 452         *
 453         * @since 2.1
 454         * @return       @c true if the next token can be translated into a valid @c signed @c char value in the current radix, @n
 455         *                               else @c false
 456         * @param[in]    radix     The radix used to translate the token as a valid @c signed @c char value
 457         */
 458         bool IsNextTokenConvertibleToSignedChar(int radix) const;
 459
 460         /**
 461         * Checks whether the next token can be translated into a valid @c int value in the default radix. @n
 462         * The @c signed integer can hold values from -2^31 to 2^31-1.
 463         *
 464         * @since 2.1
 465         * @return   @c true if the next token can be translated into a valid @c int value in the current radix, @n
 466         *                       else @c false
 467         */
 468         bool IsNextTokenConvertibleToInt(void) const;
 469
 470         /**
 471         * Checks whether the next token can be translated into a valid @c int value in the specified @c radix. @n
 472         * The @c signed integer can hold values from -2^31 to 2^31-1.
 473         *
 474         * @since 2.1
 475         * @return       @c true if the next token can be translated into a valid @c int value in the current radix, @n
 476         *                               else @c false
 477         * @param[in]    radix     The radix used to translate the token as a valid @c int value
 478         */
 479         bool IsNextTokenConvertibleToInt(int radix) const;
 480
 481         /**
 482         * Checks whether the next token can be translated into a valid @c short value in the default radix. @n
 483         * The @c signed @c short can hold values from -2^15 to 2^15-1.
 484         *
 485         * @since 2.1
 486         * @return     @c true if the next token can be translated into a valid @c short value in the current radix, @n
 487         *                         else @c false
 488         */
 489         bool IsNextTokenConvertibleToShort(void) const;
 490
 491         /**
 492         * Checks whether the next token can be translated into a valid @c short value in the specified @c radix. @n
 493         * The @c signed @c short can hold values from -2^15 to 2^15-1.
 494         *
 495         * @since 2.1
 496         * @return       @c true if the next token can be translated into a valid @c short value in the current radix, @n
 497         *                               else @c false
 498         * @param[in]    radix     The radix used to translate the token as a valid @c short value
 499         */
 500         bool IsNextTokenConvertibleToShort(int radix) const;
 501
 502         /**
 503         * Checks whether the next token can be translated into a valid @c long @c long value. @n
 504         * The @c signed @c long @c long can hold value from -2^63 to 2^63-1.
 505         *
 506         * @since 2.1
 507         * @return       @c true if the next token can be translated into a valid @c long @c long value in the current radix, @n
 508         *                               else @c false
 509         */
 510         bool IsNextTokenConvertibleToLongLong(void) const;
 511
 512         /**
 513         * Checks whether the next token can be translated into a valid @c float value. @n
 514         * The @c signed @c float can hold a single-precision 32-bit floating number.
 515         *
 516         * @since 2.1
 517         * @return       @c true if the next token can be translated into a valid @c float value in the current radix, @n
 518         *                               else @c false
 519         */
 520         bool IsNextTokenConvertibleToFloat(void) const;
 521
 522         /**
 523         * Checks whether the next token can be translated into a valid @c double value. @n
 524         * The signed @c double can hold a double-precision 64-bit floating number.
 525         *
 526         * @since 2.1
 527         * @return       @c true if the next token can be translated into a valid @c double value in the current radix, @n
 528         *                               else @c false
 529         */
 530         bool IsNextTokenConvertibleToDouble(void) const;
 531
 532         /**
 533         * Checks whether the next token can be translated into a valid @c bool value. @n
 534         * Nothing can be converted except true/TRUE or false/FALSE.
 535         *
 536         * @since 2.1
 537         * @return       @c true if the next token can be translated into a valid @c bool value, @n
 538         *                               else @c false
 539         */
 540         bool IsNextTokenConvertibleToBool(void) const;
 541
 542         /**
 543         * Checks whether the input data of the current instance of %Scanner has another line.
 544         *
 545         * @since 2.1
 546         * @return       @c true if the input data of the current instance of %Scanner has another line, @n
 547         *                               else @c false
 548         */
 549         bool HasNextLine(void) const;
 550
 551         /**
 552         * Sets the radix of the current instance of %Scanner to the specified @c radix.
 553         *
 554         * @since 2.1
 555         * @param[in]    radix     The radix to use for conversion
 556         *
 557         */
 558         void SetRadix(int radix);
 559
 560         /**
 561         * Sets the delimiter of the current instance of %Scanner to the pattern constructed from the specified delimiter.
 562         *
 563         * @since 2.1
 564         * @param[in]    patternStr      The delimiter to construct the pattern
 565         */
 566         void SetDelimiter(const String& patternStr);
 567
 568         /**
 569         * Sets the delimiter of the current instance of %Scanner to the specified @c pattern.
 570         *
 571         * @since 2.1
 572         * @param[in]    pattern  The pattern to use as a delimiter
 573         */
 574         void SetDelimiter(const RegularExpression& pattern);
 575
 576         /**
 577         * Skips the pattern constructed from the specified string.
 578         *
 579         * @since 2.1
 580         * @param[in]    patternStr  The string to construct the pattern
 581         * @remarks      If no match to the specified pattern is found at the current position, nothing is skipped.
 582         *
 583         * The following example demonstrates how to use the %Skip() method.
 584         *
 585         * @code
 586         *
 587         *       const String str("28 1   Ball 2 Ball 3.4 Ball 5 Ball red Ball blue Ball 8 89  67 21474836899.11 NaN 3.4e+5 +23   89 01010 456 123.456");
 588         *       const String skipStr("28 1   ");
 589         *       bool res = false;
 590         *       String out;
 591         *       Scanner scan;
 592         *
 593         *       scan.Construct(str);
 594         *
 595         *       //Skips "28 1" from input string
 596         *       scan.Skip(skipStr);
 597         *
 598         *       if (scan1.HasNextToken())
 599         *       {
 600         *               scan.GetNextToken(out); //returns Ball
 601         *       }
 602         *       else
 603         *       {
 604         *               return;
 605         *       }
 606         *
 607         * @endcode
 608         */
 609         void Skip(const String& patternStr);
 610
 611         /**
 612         * Skips the specified @c pattern.
 613         *
 614         * @since 2.1
 615         * @param[in]    pattern  The pattern to use to skip
 616         * @remarks      If no match to the specified pattern is found at the current position, nothing is skipped.
 617         */
 618         void Skip(const RegularExpression& pattern);
 619
 620 private:
 621         friend class _ScannerImpl;
 622         class _ScannerImpl* __pScannerImpl;
 623 }; // Scanner
 624
 625 }}}   // Tizen::Base::Utility
 626
 627 #endif // _FBASE_UTIL_SCANNER_H_