src/base/utility/FBaseUtil_ScannerImpl.cpp

   1 #include <sys/stat.h>
   2 #include <stdio.h>
   3 #include <errno.h>
   4 #include <wchar.h>
   5
   6 #include <FBaseCharacter.h>
   7 #include <FBaseInt8.h>
   8 #include <FBaseInteger.h>
   9 #include <FBaseShort.h>
  10 #include <FBaseLong.h>
  11 #include <FBaseLongLong.h>
  12 #include <FBaseFloat.h>
  13 #include <FBaseDouble.h>
  14 #include <FBaseResult.h>
  15 #include "FBaseUtil_ScannerImpl.h"
  16 #include "FBaseUtilRegularExpression.h"
  17 #include <FBaseColArrayList.h>
  18 #include <FBaseSysLog.h>
  19 #include "FBaseUtil_RegularExpressionImpl.h"
  20 #include "FBase_StringConverter.h"
  21 #include "FBaseUtil_IcuConverter.h"
  22 #include "FBase_NativeError.h"
  23
  24 #define ANY_PATTERN L"\\s*[^\\s]*"
  25 #define DEFAULT_DELIMITER_PATTERN L"\\s*"
  26 #define COMPLETE_LINE_PATTERN L".*(\r\n|[\u000A\n\r\u2028\u2029\u0085])|.+$"
  27 #define DEFAULT_LINE_SEPARATOR_PATTERN L"[\u000A\n\r\u2028\u2029\u0085]*"
  28
  29
  30 #define DEFAULT_GROUP_SEPARATOR L","
  31 #define DEFAULT_DECIMAL_SEPARATOR L"."
  32 #define DEFAULT_NEGATIVE_PREFIX L"-"
  33
  34 using namespace Tizen::Base::Collection;
  35 using namespace Tizen::Base::Utility;
  36 using namespace Tizen::Base;
  37
  38 namespace Tizen { namespace Base { namespace Utility
  39 {
  40 _ScannerImpl::_ScannerImpl(void)
  41         :__radix(10),
  42          __delimiter(DEFAULT_DELIMITER_PATTERN),
  43          __pParseStr(null),
  44          __isAllocatedOnHeap(false),
  45          __position(0)
  46 {
  47
  48 }
  49
  50 _ScannerImpl::~_ScannerImpl()
  51 {
  52         if(__isAllocatedOnHeap == true)
  53         {
  54                 delete[] __pParseStr;
  55                 __pParseStr = null;
  56         }
  57 }
  58
  59 result _ScannerImpl::Construct(const String& str)
  60 {
  61         result r = E_SUCCESS;
  62         __pParseStr = str.GetPointer();
  63         return r;
  64 }
  65
  66 result _ScannerImpl::Construct(const String& filePath, const String& encodingScheme)
  67 {
  68         result r = E_SUCCESS;
  69         FILE* pFile = null;
  70         char* pFilePath = null;
  71         bool res =  false;
  72         _ICUConverter converter;
  73         struct stat st;
  74         off_t fileSize = 0;
  75         char* buffer = null;
  76         int retVal = 0;
  77         long int readCnt = 0;
  78
  79         pFilePath = _StringConverter::CopyToCharArrayN(filePath);
  80         SysTryReturnResult(NID_BASE_UTIL, pFilePath != null, GetLastResult(), "File path length < 0 or E_OUT_OF_MEMORY");
  81
  82         res = converter.OpenConverter(encodingScheme);
  83         r = GetLastResult();
  84         SysTryCatch(NID_BASE_UTIL, res == true, , r, "[%s] Encoding scheme not supported", GetErrorMessage(r));
  85
  86         pFile = fopen(pFilePath, "r");
  87         SysTryCatch(NID_BASE_UTIL, pFile != null, r = E_FILE_NOT_FOUND, E_FILE_NOT_FOUND,
  88                         "[%s] Failed to open the file.", GetErrorMessage(__ConvertNativeErrorToResult(errno)));
  89
  90         retVal = stat(pFilePath, &st);
  91         SysTryCatch(NID_BASE_UTIL, retVal == 0, r = E_IO, E_IO,
  92                         "[%s] Failed to get information about the file.", GetErrorMessage(__ConvertNativeErrorToResult(errno)));
  93
  94         fileSize = st.st_size + 1;      // +1 for null-terminated string
  95
  96         buffer = static_cast<char*>(calloc(fileSize, sizeof(char)));
  97         SysTryCatch(NID_BASE_UTIL, buffer != null, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY]");
  98         readCnt = fread(buffer, 1, fileSize - 1, pFile);
  99
 100         if (readCnt < fileSize)
 101         {
 102                 int ret = ferror(pFile);
 103                 SysTryCatch(NID_BASE_UTIL, ret == 0, r = E_IO, E_IO, "[%s] Failed to perform read operation.", GetErrorMessage(E_IO));
 104         }
 105
 106         __pParseStr = converter.ConvertToUcharN(buffer, fileSize);
 107         SysTryCatch(NID_BASE_UTIL, __pParseStr != null, r = E_IO, E_IO , "[%s] charcater conversion failed.", GetErrorMessage(E_IO));
 108         __isAllocatedOnHeap = true;
 109
 110 CATCH:
 111         delete[] pFilePath;
 112         pFilePath = null;
 113
 114         delete[] buffer;
 115         buffer = null;
 116
 117         if(pFile != null)
 118         {
 119                 fclose(pFile);
 120                 pFile = null;
 121         }
 122
 123         return r;
 124 }
 125
 126 bool _ScannerImpl::HasNextToken(void)
 127 {
 128         String pattern(ANY_PATTERN);
 129         return HasNextToken(pattern);
 130 }
 131
 132 bool _ScannerImpl::HasNextToken(const RegularExpression& pattern)
 133 {
 134         String patStr(pattern.GetPattern());
 135         return HasNextToken(patStr);
 136 }
 137
 138 bool _ScannerImpl::HasNextToken(const String& pattern)
 139 {
 140         result r = E_SUCCESS;
 141         String token;
 142         int length = 0;
 143
 144         r = GetNextToken(pattern, token, length);
 145         SysTryReturn(NID_BASE_UTIL, r == E_SUCCESS, false, E_DATA_NOT_FOUND, "[%s] Can not get the next token", GetErrorMessage(E_DATA_NOT_FOUND));
 146
 147         return true;
 148 }
 149
 150
 151 result _ScannerImpl::GetNextToken(String& nextStr)
 152 {
 153         result r = E_SUCCESS;
 154         String pattern(ANY_PATTERN);
 155         int length = 0;
 156
 157         r = GetNextToken(pattern, nextStr, length);
 158         SysTryReturnResult(NID_BASE_UTIL, r == E_SUCCESS, E_DATA_NOT_ENOUGH, "Can not get the next token");
 159
 160         __position =  __position + length;
 161
 162         return r;
 163 }
 164
 165 result _ScannerImpl::GetNextToken(const RegularExpression& pattern, String& nextStr)
 166 {
 167         String patStr(pattern.GetPattern());
 168         return GetNextToken(patStr, nextStr);
 169 }
 170
 171 result _ScannerImpl::GetNextToken(const String& pattern, String& nextStr)
 172 {
 173         result r = E_SUCCESS;
 174         int length1 = 0;
 175         int length2 = 0;
 176
 177         String str1;
 178         String str2;
 179         String anyPattern(ANY_PATTERN);
 180
 181         while (true)
 182         {
 183                 r = GetNextToken(anyPattern, str1, length1);
 184                 SysTryReturnResult(NID_BASE_UTIL, r != E_DATA_NOT_ENOUGH, E_DATA_NOT_ENOUGH, "Input has no remaining tokens");
 185                 SysTryReturnResult(NID_BASE_UTIL, r == E_SUCCESS, E_DATA_NOT_FOUND, "The next token does not match to the pattern");
 186
 187                 r = GetNextToken(pattern, str2, length2);
 188                 SysTryReturnResult(NID_BASE_UTIL, r != E_DATA_NOT_ENOUGH, E_DATA_NOT_ENOUGH, "Input has no remaining tokens");
 189                 SysTryReturnResult(NID_BASE_UTIL, r == E_SUCCESS, E_DATA_NOT_FOUND, "The next token does not match to the pattern");
 190
 191                 if(str1 == str2)
 192                 {
 193                         nextStr = str1;
 194                         __position =  __position + length2;
 195                         break;
 196                 }
 197                 else
 198                 {
 199                         nextStr = L"";
 200                         __position = __position + length1;
 201                 }
 202         }
 203
 204         return r;
 205 }
 206
 207 result _ScannerImpl::GetNextSignedChar(signed char& nextSignedChar)
 208 {
 209         return GetNextSignedChar(nextSignedChar, __radix);
 210 }
 211
 212 result _ScannerImpl::GetNextSignedChar(signed char& nextSignedChar, int radix)
 213 {
 214         result r = E_SUCCESS;
 215         String out;
 216         int length = 0;
 217         char ch = 0x00;
 218         String pattern(ANY_PATTERN);
 219
 220         r = GetNextToken(pattern, out, length);
 221         SysTryReturnResult(NID_BASE_UTIL, r != E_DATA_NOT_ENOUGH, E_DATA_NOT_ENOUGH, "Input has no remaining tokens");
 222         SysTryReturnResult(NID_BASE_UTIL, r == E_SUCCESS, E_NUM_FORMAT, "Can not parse the token to signed char");
 223
 224         r = Int8::Parse(out, radix, ch);
 225         SysTryReturnResult(NID_BASE_UTIL, r == E_SUCCESS, E_NUM_FORMAT, "Can not parse the token to signed char");
 226
 227         nextSignedChar = static_cast<signed char>(ch);
 228         __position =  __position + length;
 229
 230         return r;
 231 }
 232
 233 bool _ScannerImpl::IsNextTokenConvertibleToSignedChar(void)
 234 {
 235         return IsNextTokenConvertibleToSignedChar(__radix);
 236 }
 237
 238 bool _ScannerImpl::IsNextTokenConvertibleToSignedChar(int radix)
 239 {
 240         result r = E_SUCCESS;
 241         String out;
 242         int length = 0;
 243         String pattern(ANY_PATTERN);
 244         char ch = 0;
 245
 246         r = GetNextToken(pattern, out, length);
 247         SysTryReturn(NID_BASE_UTIL, r == E_SUCCESS, false, E_NUM_FORMAT, "[%s] Can not get the next token as signed char", GetErrorMessage(E_NUM_FORMAT));
 248
 249         r = Int8::Parse(out, radix, ch);
 250         SysTryReturn(NID_BASE_UTIL, r == E_SUCCESS, false, E_NUM_FORMAT, "[%s] Can not parse the token to signed char", GetErrorMessage(E_NUM_FORMAT));
 251
 252         return true;
 253 }
 254
 255 result _ScannerImpl::GetNextInt(int& nextInt)
 256 {
 257         return GetNextInt(nextInt, __radix);
 258 }
 259
 260 result _ScannerImpl::GetNextInt(int& nextInt, int radix)
 261 {
 262         result r = E_SUCCESS;
 263         String out;
 264         int length = 0;
 265         String pattern(ANY_PATTERN);
 266
 267         r = GetNextToken(pattern, out, length);
 268         SysTryReturnResult(NID_BASE_UTIL, r != E_DATA_NOT_ENOUGH, E_DATA_NOT_ENOUGH, "Input has no remaining tokens");
 269         SysTryReturnResult(NID_BASE_UTIL, r == E_SUCCESS, E_NUM_FORMAT, "Can not parse the token to integer");
 270
 271         out.Replace(DEFAULT_GROUP_SEPARATOR, L"");
 272         r = Integer::Parse(out, radix, nextInt);
 273         SysTryReturnResult(NID_BASE_UTIL, r == E_SUCCESS, E_NUM_FORMAT, "Can not parse the token to integer");
 274
 275         __position =  __position + length;
 276
 277         return r;
 278 }
 279
 280 bool _ScannerImpl::IsNextTokenConvertibleToInt(void)
 281 {
 282         return IsNextTokenConvertibleToInt(__radix);
 283 }
 284
 285 bool _ScannerImpl::IsNextTokenConvertibleToInt(int radix)
 286 {
 287         result r = E_SUCCESS;
 288         String out;
 289         int val = 0;
 290         int length = 0;
 291         String pattern(ANY_PATTERN);
 292
 293         r = GetNextToken(pattern, out, length);
 294         SysTryReturn(NID_BASE_UTIL, r == E_SUCCESS, false, E_NUM_FORMAT, "[%s] Can not get the next token as integer", GetErrorMessage(E_NUM_FORMAT));
 295
 296         out.Replace(DEFAULT_GROUP_SEPARATOR, L"");
 297         r = Integer::Parse(out, radix, val);
 298         SysTryReturn(NID_BASE_UTIL, r == E_SUCCESS, false, E_NUM_FORMAT, "[%s] Can not get next Integer", GetErrorMessage(E_NUM_FORMAT));
 299
 300         return true;
 301 }
 302
 303 result _ScannerImpl::GetNextShort(short& nextShort)
 304 {
 305         return GetNextShort(nextShort, __radix);
 306 }
 307
 308 result _ScannerImpl::GetNextShort(short& nextShort, int radix)
 309 {
 310         result r = E_SUCCESS;
 311         String out;
 312         int length = 0;
 313         String pattern(ANY_PATTERN);
 314
 315         r = GetNextToken(pattern, out, length);
 316         SysTryReturnResult(NID_BASE_UTIL, r != E_DATA_NOT_ENOUGH, E_DATA_NOT_ENOUGH, "Input has no remaining tokens");
 317         SysTryReturnResult(NID_BASE_UTIL, r == E_SUCCESS, E_NUM_FORMAT, "Can not parse the token to short");
 318
 319         out.Replace(DEFAULT_GROUP_SEPARATOR, L"");
 320         r = Short::Parse(out, radix, nextShort);
 321         SysTryReturnResult(NID_BASE_UTIL, r == E_SUCCESS, E_NUM_FORMAT, "Can not parse the token to short");
 322
 323         __position =  __position + length;
 324
 325         return r;
 326 }
 327
 328 bool _ScannerImpl::IsNextTokenConvertibleToShort(void)
 329 {
 330         return IsNextTokenConvertibleToShort(__radix);
 331 }
 332
 333 bool _ScannerImpl::IsNextTokenConvertibleToShort(int radix)
 334 {
 335         result r = E_SUCCESS;
 336         String out;
 337         short val = 0;
 338         int length = 0;
 339         String pattern(ANY_PATTERN);
 340
 341         r = GetNextToken(pattern, out, length);
 342         SysTryReturn(NID_BASE_UTIL, r == E_SUCCESS, false, E_NUM_FORMAT, "[%s] Can not get next token as short", GetErrorMessage(E_NUM_FORMAT));
 343
 344         out.Replace(DEFAULT_GROUP_SEPARATOR, L"");
 345         r = Short::Parse(out, radix, val);
 346         SysTryReturn(NID_BASE_UTIL, r == E_SUCCESS, false, E_NUM_FORMAT, "[%s] Can not get next short", GetErrorMessage(E_NUM_FORMAT));
 347
 348         return true;
 349 }
 350
 351 result _ScannerImpl::GetNextLongLong(long long& nextLongLong)
 352 {
 353         return GetNextLongLong(nextLongLong, __radix);
 354 }
 355
 356 result _ScannerImpl::GetNextLongLong(long long& nextLongLong, int radix)
 357 {
 358         result r = E_SUCCESS;
 359         String out;
 360         int length = 0;
 361         String pattern(ANY_PATTERN);
 362
 363         r = GetNextToken(pattern, out, length);
 364         SysTryReturnResult(NID_BASE_UTIL, r != E_DATA_NOT_ENOUGH, E_DATA_NOT_ENOUGH, "Input has no remaining tokens");
 365         SysTryReturnResult(NID_BASE_UTIL, r == E_SUCCESS, E_NUM_FORMAT, "Can not parse the token to long long");
 366
 367         out.Replace(DEFAULT_GROUP_SEPARATOR, L"");
 368         r = LongLong::Parse(out, radix, nextLongLong);
 369         SysTryReturnResult(NID_BASE_UTIL, r == E_SUCCESS, E_NUM_FORMAT, "Can not parse the token to long long");
 370
 371         __position =  __position + length;
 372
 373         return r;
 374 }
 375
 376 bool _ScannerImpl::IsNextTokenConvertibleToLongLong(void)
 377 {
 378         result r = E_SUCCESS;
 379         String out;
 380         long long val = 0;
 381         int length = 0;
 382         String pattern(ANY_PATTERN);
 383
 384         r = GetNextToken(pattern, out, length);
 385         SysTryReturn(NID_BASE_UTIL, r == E_SUCCESS, false, E_NUM_FORMAT, "[E_NUM_FORMAT] Can not get next token as long long");
 386
 387         r = LongLong::Parse(out, val);
 388         SysTryReturn(NID_BASE_UTIL, r == E_SUCCESS, false, E_NUM_FORMAT, "[E_NUM_FORMAT] Can not get next long long");
 389
 390         return true;
 391 }
 392
 393 result _ScannerImpl::GetNextFloat(float& nextFloat)
 394 {
 395         result r = E_SUCCESS;
 396         String out;
 397         int length = 0;
 398         String pattern(ANY_PATTERN);
 399
 400         r = GetNextToken(pattern, out, length);
 401         SysTryReturnResult(NID_BASE_UTIL, r != E_DATA_NOT_ENOUGH, E_DATA_NOT_ENOUGH, "Input has no remaining tokens");
 402         SysTryReturnResult(NID_BASE_UTIL, r == E_SUCCESS, E_NUM_FORMAT, "Can not parse the token to float");
 403
 404         out.Replace(DEFAULT_GROUP_SEPARATOR, L"");
 405         r = Float::Parse(out, nextFloat);
 406         SysTryReturnResult(NID_BASE_UTIL, r == E_SUCCESS, E_NUM_FORMAT, "Can not parse the token to float");
 407
 408         __position =  __position + length;
 409
 410         return r;
 411 }
 412
 413
 414 bool _ScannerImpl::IsNextTokenConvertibleToFloat(void)
 415 {
 416         result r = E_SUCCESS;
 417         String out;
 418         RegularExpression re;
 419         float val = 0.0f;
 420         int length = 0;
 421         String pattern(ANY_PATTERN);
 422
 423         r = GetNextToken(pattern, out, length);
 424         SysTryReturn(NID_BASE_UTIL, r == E_SUCCESS, false, E_NUM_FORMAT, "[%s] Can not get next token as float", GetErrorMessage(E_NUM_FORMAT));
 425
 426         out.Replace(DEFAULT_GROUP_SEPARATOR, L"");
 427         r = Float::Parse(out, val);
 428         SysTryReturn(NID_BASE_UTIL, r == E_SUCCESS, false, E_NUM_FORMAT, "[%s] Can not get next float", GetErrorMessage(E_NUM_FORMAT));
 429
 430         return true;
 431 }
 432
 433 result _ScannerImpl::GetNextDouble(double& nextDouble)
 434 {
 435         result r = E_SUCCESS;
 436         String out;
 437         int length = 0;
 438         String pattern(ANY_PATTERN);
 439
 440         r = GetNextToken(pattern, out, length);
 441         SysTryReturnResult(NID_BASE_UTIL, r != E_DATA_NOT_ENOUGH, E_DATA_NOT_ENOUGH, "Input has no remaining tokens");
 442         SysTryReturnResult(NID_BASE_UTIL, r == E_SUCCESS, E_NUM_FORMAT, "Can not parse the token to double");
 443
 444         out.Replace(DEFAULT_GROUP_SEPARATOR, L"");
 445         r = Double::Parse(out, nextDouble);
 446         SysTryReturnResult(NID_BASE_UTIL, r == E_SUCCESS, E_NUM_FORMAT, "Can not parse the token to double");
 447
 448         __position =  __position + length;
 449
 450         return r;
 451 }
 452
 453 bool _ScannerImpl::IsNextTokenConvertibleToDouble(void)
 454 {
 455         result r = E_SUCCESS;
 456         String out;
 457         double val = 0.0f;
 458         int length = 0;
 459         String pattern(ANY_PATTERN);
 460
 461         r = GetNextToken(pattern, out, length);
 462         SysTryReturn(NID_BASE_UTIL, r == E_SUCCESS, false, E_NUM_FORMAT, "[%s] Can not get next token as double", GetErrorMessage(E_NUM_FORMAT));
 463
 464         out.Replace(DEFAULT_GROUP_SEPARATOR, L"");
 465         r = Double::Parse(out, val);
 466         SysTryReturn(NID_BASE_UTIL, r == E_SUCCESS, false, E_NUM_FORMAT, "[%s] Can not get next token", GetErrorMessage(E_NUM_FORMAT));
 467
 468         return true;
 469 }
 470
 471 result _ScannerImpl::GetNextBool(bool& nextBool)
 472 {
 473         result r = E_SUCCESS;
 474         String out;
 475         int length = 0;
 476         String pattern(ANY_PATTERN);
 477
 478         r = GetNextToken(pattern, out, length);
 479         SysTryReturnResult(NID_BASE_UTIL, r != E_DATA_NOT_ENOUGH, E_DATA_NOT_ENOUGH, "Input has no remaining tokens");
 480         SysTryReturnResult(NID_BASE_UTIL, r == E_SUCCESS, E_NUM_FORMAT, "Can not parse the token to bool");
 481
 482         String temp;
 483         r = out.ToUpper(temp);
 484         SysTryReturnResult(NID_BASE_UTIL, r == E_SUCCESS, E_NUM_FORMAT, "Can not get next bool");
 485
 486         if(!temp.CompareTo(L"TRUE"))
 487         {
 488                 nextBool = true;
 489                 __position =  __position + length;
 490         }
 491         else if(!temp.CompareTo(L"FALSE"))
 492         {
 493                 nextBool = false;
 494                 __position =  __position + length;
 495         }
 496         else
 497         {
 498                 r =  E_NUM_FORMAT;
 499         }
 500
 501         return r;
 502 }
 503
 504 bool _ScannerImpl::IsNextTokenConvertibleToBool(void)
 505 {
 506         result r = E_SUCCESS;
 507         String out;
 508         bool ret = false;
 509         int length = 0;
 510         String pattern(ANY_PATTERN);
 511
 512         r = GetNextToken(pattern, out, length);
 513         SysTryReturn(NID_BASE_UTIL, r == E_SUCCESS, false, E_NUM_FORMAT, "[%s] Can not get next token as bool", GetErrorMessage(E_NUM_FORMAT));
 514
 515         String temp;
 516         out.ToUpper(temp);
 517         if((!temp.CompareTo(L"TRUE")) || (!temp.CompareTo(L"FALSE")))
 518         {
 519                 ret = true;
 520         }
 521         else
 522         {
 523                 ret = false;
 524         }
 525
 526         return ret;
 527 }
 528
 529 bool _ScannerImpl::HasNextLine(void)
 530 {
 531         result r = E_SUCCESS;
 532         String pattern(DEFAULT_LINE_SEPARATOR_PATTERN);
 533         RegularExpression regex;
 534         ArrayList matchedStrList;
 535         bool res = false;
 536
 537         r = regex.Construct(pattern, REGEX_UNICODE);
 538         SysTryReturn(NID_BASE_UTIL, r == E_SUCCESS, false, E_DATA_NOT_ENOUGH, "[%s] Regular expression construction failed", GetErrorMessage(E_DATA_NOT_ENOUGH));
 539
 540         r = matchedStrList.Construct();
 541         SysTryReturn(NID_BASE_UTIL, r == E_SUCCESS, false, E_DATA_NOT_ENOUGH, "[%s] Arraylist construction failed", GetErrorMessage(E_DATA_NOT_ENOUGH));
 542
 543         res = regex.Match(String(__pParseStr + __position), false, &matchedStrList);
 544         SysTryReturn(NID_BASE_UTIL, res == true, false, E_DATA_NOT_ENOUGH, "[%s] Match Failed", GetErrorMessage(E_DATA_NOT_ENOUGH));
 545
 546         return res;
 547 }
 548
 549
 550 result _ScannerImpl::GetNextLine(String& nextLine)
 551 {
 552         result r = E_SUCCESS;
 553         String pattern(COMPLETE_LINE_PATTERN);
 554         RegularExpression regex;
 555         ArrayList matchedStrList;
 556         bool res = false;
 557         int matches = 0;
 558
 559         r = regex.Construct(pattern, REGEX_UNICODE);
 560         SysTryReturnResult(NID_BASE_UTIL, r == E_SUCCESS, E_DATA_NOT_ENOUGH, "Regular expression construction failed");
 561
 562         r = matchedStrList.Construct();
 563         SysTryReturnResult(NID_BASE_UTIL, r == E_SUCCESS, E_DATA_NOT_ENOUGH, "Arraylist construction failed");
 564
 565         res = regex.Match(String(__pParseStr + __position), false, &matchedStrList);
 566         SysTryReturnResult(NID_BASE_UTIL, res == true, E_DATA_NOT_ENOUGH, "Match Failed");
 567
 568         matches = matchedStrList.GetCount();
 569         if(matches > 0)
 570         {
 571                 String temp = *(String *)matchedStrList.GetAt(0);
 572                 __position = __position + temp.GetLength();
 573
 574                 RegularExpression re;
 575                 r = re.Construct(DEFAULT_LINE_SEPARATOR_PATTERN, REGEX_UNICODE);
 576                 re.Replace(temp, L"", true);
 577                 nextLine = temp;
 578
 579                 matchedStrList.RemoveAll();
 580         }
 581
 582         return r;
 583
 584 }
 585
 586 result _ScannerImpl::FindInLine(const String& str, String& MatchedStr)
 587 {
 588         result r = E_SUCCESS;
 589         _RegularExpressionImpl regex;
 590         ArrayList matchedStrList;
 591         bool res = false;
 592         int matches = 0;
 593
 594         r = regex.Construct(str, REGEX_UNICODE);
 595         SysTryReturnResult(NID_BASE_UTIL, r == E_SUCCESS, E_DATA_NOT_FOUND, "Regular expression construction failed");
 596
 597         r = matchedStrList.Construct();
 598         SysTryReturnResult(NID_BASE_UTIL, r == E_SUCCESS, E_DATA_NOT_FOUND, "Arraylist construction failed");
 599
 600         res = regex.Match(String(__pParseStr + __position), false, &matchedStrList);
 601         SysTryReturnResult(NID_BASE_UTIL, res == true, E_DATA_NOT_FOUND, "Match Failed");
 602
 603         matches = matchedStrList.GetCount();
 604         if(matches > 0)
 605         {
 606                 MatchedStr = *(String *)matchedStrList.GetAt(0);
 607                 int matchEnd = regex.GetLastMatchEnd();
 608                 __position = __position + matchEnd;
 609                 matchedStrList.RemoveAll();
 610         }
 611         return r;
 612
 613 }
 614
 615 result _ScannerImpl::FindInLine(const RegularExpression& pattern, String& MatchedStr)
 616 {
 617         String patStr(pattern.GetPattern());
 618         return FindInLine(patStr, MatchedStr);
 619 }
 620
 621 void _ScannerImpl::Skip(const String& str)
 622 {
 623         result r = E_SUCCESS;
 624         RegularExpression regex;
 625         ArrayList matchedStrList;
 626         bool res = false;
 627         int matches = 0;
 628
 629         r = regex.Construct(str, REGEX_UNICODE);
 630         SysTryCatch(NID_BASE_UTIL, r == E_SUCCESS, , r, "[%s] Regular expression construction failed", GetErrorMessage(r));
 631
 632         r = matchedStrList.Construct();
 633         SysTryCatch(NID_BASE_UTIL, r == E_SUCCESS, , r, "[%s] ArrayList construction failed", GetErrorMessage(r));
 634
 635         res = regex.Match(String(__pParseStr + __position), false, &matchedStrList);
 636         SysTryCatch(NID_BASE_UTIL, res == true, , E_SYSTEM, "[%s] Regular expression match failed", GetErrorMessage(E_SYSTEM));
 637
 638         matches = matchedStrList.GetCount();
 639          if(matches > 0)
 640          {
 641                         String temp = *(String *)matchedStrList.GetAt(0);
 642                         int length = temp.GetLength();
 643                         const wchar_t* wstr1 = temp.GetPointer();
 644                         const wchar_t* wstr2 = __pParseStr + __position;
 645                         bool isSame = true;
 646
 647                         while(*wstr1 != 0x0000)
 648                         {
 649                                 if(*wstr1++ != *wstr2++)
 650                                 {
 651                                         isSame =  false;
 652                                         break;
 653                                 }
 654                         }
 655                         if(isSame == true)
 656                         {
 657                                 __position = __position + length;
 658                         }
 659                         matchedStrList.RemoveAll();
 660
 661                         //Skip if there is any delimiters before the next token
 662                         RegularExpression re;
 663                         r = re.Construct(DEFAULT_DELIMITER_PATTERN, REGEX_UNICODE);
 664                         res = re.Match(String(__pParseStr + __position), false, &matchedStrList);
 665                         matches = matchedStrList.GetCount();
 666                          if(matches > 0)
 667                          {
 668                                         String temp = *(String *)matchedStrList.GetAt(0);
 669                                         int length = temp.GetLength();
 670                                         __position = __position + length;
 671                                         matchedStrList.RemoveAll();
 672                          }
 673
 674          }
 675
 676 CATCH:
 677         return;
 678 }
 679
 680 void _ScannerImpl::Skip(const RegularExpression& pattern)
 681 {
 682         String patStr(pattern.GetPattern());
 683         return Skip(patStr);
 684 }
 685
 686 int _ScannerImpl::GetRadix(void)
 687 {
 688         return __radix;
 689 }
 690
 691 String _ScannerImpl::GetDelimiter(void)
 692 {
 693         return __delimiter;
 694 }
 695
 696 void _ScannerImpl::SetDelimiter(const String& delimiter)
 697 {
 698         __delimiter = delimiter;
 699 }
 700
 701 void _ScannerImpl::SetDelimiter(const RegularExpression& pattern)
 702 {
 703         __delimiter = pattern.GetPattern();
 704 }
 705
 706 void _ScannerImpl::SetRadix(int radix)
 707 {
 708         if(((radix == Character::RADIX_BINARY) || (radix == Character::RADIX_OCTAL) ||
 709                 (radix == Character::RADIX_DECIMAL) || (radix == Character::RADIX_HEXADECIMAL)))
 710         {
 711                 __radix = radix;
 712         }
 713 }
 714
 715 result _ScannerImpl::GetNextToken(const String& pattern, String& ret, int& length)
 716 {
 717         result r = E_SUCCESS;
 718         SysTryReturnResult(NID_BASE_UTIL, __pParseStr + __position != null, E_DATA_NOT_ENOUGH, "Input has no remaining tokens.");
 719         SysTryReturnResult(NID_BASE_UTIL, *(__pParseStr + __position) != 0x0000, E_DATA_NOT_ENOUGH, "Input has no remaining tokens.");
 720
 721         RegularExpression regex;
 722         ArrayList matchedStrList;
 723         bool res = false;
 724         int matches = 0;
 725         String regPattern(pattern);
 726
 727         regPattern.Append(__delimiter);
 728
 729         r = regex.Construct(regPattern, REGEX_UNICODE);
 730         SysTryReturnResult(NID_BASE_UTIL, r == E_SUCCESS, E_OPERATION_FAILED, "Regular expression construction failed");
 731
 732         r = matchedStrList.Construct();
 733         SysTryReturnResult(NID_BASE_UTIL, r == E_SUCCESS, E_OPERATION_FAILED, "Arraylist construction failed");
 734
 735         res = regex.Match(String(__pParseStr + __position), false, &matchedStrList);
 736         SysTryReturnResult(NID_BASE_UTIL, res == true, E_OPERATION_FAILED, "Match Failed");
 737
 738         matches = matchedStrList.GetCount();
 739         if(matches > 0)
 740         {
 741                 String temp = *(String *)matchedStrList.GetAt(0);
 742                 length = temp.GetLength();
 743                 RegularExpression re;
 744                 r = re.Construct(__delimiter, REGEX_UNICODE);
 745                 re.Replace(temp, L"", true);
 746                 ret = temp;
 747                 matchedStrList.RemoveAll();
 748         }
 749
 750         return r;
 751 }
 752
 753 result _ScannerImpl::GetNextMatchingString(const String& pattern, String& ret, int& length)
 754 {
 755         result r = E_SUCCESS;
 756         RegularExpression regex;
 757         ArrayList matchedStrList;
 758
 759         bool res = false;
 760         int matches = 0;
 761         String nextToken;
 762         String matchToken;
 763
 764         String strPat(ANY_PATTERN);
 765         strPat.Append(DEFAULT_DELIMITER_PATTERN);
 766
 767         r = regex.Construct(strPat, REGEX_UNICODE);
 768         SysTryReturnResult(NID_BASE_UTIL, r == E_SUCCESS, E_OPERATION_FAILED, "Regular expression construction failed");
 769
 770         r = matchedStrList.Construct();
 771         SysTryReturnResult(NID_BASE_UTIL, r == E_SUCCESS, E_OPERATION_FAILED, "Arraylist construction failed");
 772
 773         res = regex.Match(String(__pParseStr + __position), false, &matchedStrList);
 774
 775         SysTryReturnResult(NID_BASE_UTIL, res == true, E_OPERATION_FAILED, "Match Failed");
 776
 777         matches = matchedStrList.GetCount();
 778         if(matches > 0)
 779         {
 780                 nextToken = *(String *)matchedStrList.GetAt(0);
 781                 matchedStrList.RemoveAll();
 782         }
 783
 784         strPat = pattern;
 785         strPat.Append(DEFAULT_DELIMITER_PATTERN);
 786         r = regex.Construct(strPat, REGEX_UNICODE);
 787         SysTryReturnResult(NID_BASE_UTIL, r == E_SUCCESS, E_OPERATION_FAILED, "Regular expression construction failed");
 788
 789         r = matchedStrList.Construct();
 790         SysTryReturnResult(NID_BASE_UTIL, r == E_SUCCESS, E_OPERATION_FAILED, "Arraylist construction failed");
 791
 792         res = regex.Match(String(__pParseStr + __position), false, &matchedStrList);
 793         SysTryReturnResult(NID_BASE_UTIL, res == true, E_OPERATION_FAILED, "Match Failed");
 794
 795         matches = matchedStrList.GetCount();
 796         if(matches > 0)
 797         {
 798                 matchToken = *(String *)matchedStrList.GetAt(0);
 799                 matchedStrList.RemoveAll();
 800
 801                 if((nextToken == matchToken) == true)
 802                 {
 803                         length = matchToken.GetLength();
 804                         RegularExpression re;
 805                         r = re.Construct(DEFAULT_DELIMITER_PATTERN, REGEX_UNICODE);
 806                         re.Replace(matchToken, L"", true);
 807                         ret = matchToken;
 808                 }
 809                 else
 810                 {
 811                         r = E_OPERATION_FAILED;
 812                 }
 813         }
 814
 815         return r;
 816 }
 817
 818 }}}   // Osp::Base::Utility