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