src/FSD/FSD_CmpFile.cxx

   1 // Copyright (c) 1998-1999 Matra Datavision
   2 // Copyright (c) 1999-2012 OPEN CASCADE SAS
   3 //
   4 // The content of this file is subject to the Open CASCADE Technology Public
   5 // License Version 6.5 (the "License"). You may not use the content of this file
   6 // except in compliance with the License. Please obtain a copy of the License
   7 // at http://www.opencascade.org and read it completely before using this file.
   8 //
   9 // The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
  10 // main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
  11 //
  12 // The Original Code and all software distributed under the License is
  13 // distributed on an "AS IS" basis, without warranty of any kind, and the
  14 // Initial Developer hereby disclaims all such warranties, including without
  15 // limitation, any warranties of merchantability, fitness for a particular
  16 // purpose or non-infringement. Please see the License for the specific terms
  17 // and conditions governing the rights and limitations under the License.
  18
  19 #include <FSD_CmpFile.ixx>
  20 #include <OSD.hxx>
  21
  22 #include <OSD_Real2String.hxx>
  23
  24 #include <Storage_StreamModeError.hxx>
  25 #include <Storage_StreamUnknownTypeError.hxx>
  26 #include <Standard_PCharacter.hxx>
  27
  28 // Propagate the improvement (BUC60808) on all platforms
  29 // #ifdef WNT
  30 #define BUC60808
  31 // BUC60808 : standard output in MS Visual C++ limites the quantity of figures (digits)
  32 // in part of number after fixed point. The quantity of figures after fixed point
  33 // could not be more than 15 when we output double number using standard MS VS output operator '<<'.
  34 // For example, the maximum double value DBL_MAX = 1.7976931348623157e+308 (see float.h) after
  35 // cout<<setprecision(17)<<DBL_MAX  becomes 1.79769313486232e+308  in stream of output
  36 // (it could be a file stream). When the number 1.79769313486232e+308 is read from the
  37 // i/o streame (file, for example) it occurs more than allowed maximum value of double
  38 // type - 1.7976931348623157e+308.  Such value is considered as infinite. When it is written
  39 // to file (for example)  again it is written as 1.#INF. Such value can't be read from file next time.
  40 //#endif
  41
  42 const Standard_CString MAGICNUMBER = "CMPFILE";
  43 const Standard_CString ENDOFNORMALEXTENDEDSECTION = "BEGIN_REF_SECTION";
  44 const Standard_Integer SIZEOFNORMALEXTENDEDSECTION = 16;
  45
  46 //=======================================================================
  47 //function : FSD_CmpFile
  48 //purpose  :
  49 //=======================================================================
  50
  51 FSD_CmpFile::FSD_CmpFile()
  52 {
  53
  54 }
  55
  56 //=======================================================================
  57 //function : IsGoodFileType
  58 //purpose  : INFO SECTION
  59 //           write
  60 //=======================================================================
  61
  62 Storage_Error FSD_CmpFile::IsGoodFileType(const TCollection_AsciiString& aName)
  63 {
  64   FSD_CmpFile      f;
  65   Storage_Error s;
  66
  67   s = f.Open(aName,Storage_VSRead);
  68
  69   if (s == Storage_VSOk) {
  70     TCollection_AsciiString l;
  71     Standard_Size        len = strlen(FSD_CmpFile::MagicNumber());
  72
  73     f.ReadChar(l,len);
  74
  75     f.Close();
  76
  77     if (strncmp(FSD_CmpFile::MagicNumber(),l.ToCString(),len) != 0) {
  78       s = Storage_VSFormatError;
  79     }
  80   }
  81
  82   return s;
  83 }
  84
  85 //=======================================================================
  86 //function : Open
  87 //purpose  :
  88 //=======================================================================
  89
  90 Storage_Error FSD_CmpFile::Open(const TCollection_AsciiString& aName,const Storage_OpenMode aMode)
  91 {
  92   Storage_Error result = Storage_VSOk;
  93
  94   SetName(aName);
  95
  96   if (OpenMode() == Storage_VSNone) {
  97
  98 #if !defined(IRIX) && !defined(DECOSF1)
  99     if (aMode == Storage_VSRead) {
 100       myStream.open(aName.ToCString(),ios::in|ios::binary); // ios::nocreate is not portable
 101     }
 102     else if (aMode == Storage_VSWrite) {
 103       myStream.open(aName.ToCString(),ios::out|ios::binary);
 104     }
 105     else if (aMode == Storage_VSReadWrite) {
 106       myStream.open(aName.ToCString(),ios::in|ios::out|ios::binary);
 107     }
 108 #else
 109     if (aMode == Storage_VSRead) {
 110       myStream.open(aName.ToCString(),ios::in); // ios::nocreate is not portable
 111     }
 112     else if (aMode == Storage_VSWrite) {
 113       myStream.open(aName.ToCString(),ios::out);
 114     }
 115     else if (aMode == Storage_VSReadWrite) {
 116       myStream.open(aName.ToCString(),ios::in|ios::out);
 117     }
 118 #endif
 119
 120     if (myStream.fail()) {
 121       result = Storage_VSOpenError;
 122     }
 123     else {
 124       myStream.precision(17);
 125       SetOpenMode(aMode);
 126     }
 127   }
 128   else {
 129     result = Storage_VSAlreadyOpen;
 130   }
 131   return result;
 132 }
 133
 134 //=======================================================================
 135 //function : IsEnd
 136 //purpose  :
 137 //=======================================================================
 138
 139 Standard_Boolean FSD_CmpFile::IsEnd()
 140 {
 141   return myStream.eof();
 142 }
 143
 144 //=======================================================================
 145 //function : Close
 146 //purpose  :
 147 //=======================================================================
 148
 149 Storage_Error FSD_CmpFile::Close()
 150 {
 151   Storage_Error result = Storage_VSOk;
 152
 153   if (OpenMode() != Storage_VSNone) {
 154     myStream.close();
 155     SetOpenMode(Storage_VSNone);
 156   }
 157   else {
 158     result = Storage_VSNotOpen;
 159   }
 160
 161   return result;
 162 }
 163
 164 //=======================================================================
 165 //function : MagicNumber
 166 //purpose  : ------------------ PROTECTED
 167 //=======================================================================
 168
 169 const Standard_CString FSD_CmpFile::MagicNumber()
 170 {
 171   return MAGICNUMBER;
 172 }
 173
 174 //=======================================================================
 175 //function : FlushEndOfLine
 176 //purpose  :
 177 //=======================================================================
 178
 179 void FSD_CmpFile::FlushEndOfLine()
 180 {
 181   TCollection_AsciiString aDummy;
 182   ReadLine (aDummy); // flush is nothing more than to read till the line-break
 183   /*
 184   static char Buffer[8192];
 185   char c;
 186   Standard_Boolean IsEnd = Standard_False;
 187
 188   while (!IsEnd && !FSD_CmpFile::IsEnd()) {
 189     Buffer[0] = '\0';
 190     myStream.get(Buffer,8192,'\n');
 191
 192     if (myStream.get(c) && c != '\r' && c != '\n') {
 193     }
 194     else {
 195       IsEnd = Standard_True;
 196     }
 197   }
 198   */
 199 }
 200
 201 //=======================================================================
 202 //function : ReadLine
 203 //purpose  : read from the current position to the end of line.
 204 //=======================================================================
 205
 206 void FSD_CmpFile::ReadLine(TCollection_AsciiString& buffer)
 207 {
 208   char Buffer[8193];
 209   //char c;
 210   Standard_Boolean IsEnd = Standard_False;
 211
 212   buffer.Clear();
 213
 214   while (!IsEnd && !FSD_CmpFile::IsEnd()) {
 215     Buffer[0] = '\0';
 216     //myStream.get(Buffer,8192,'\n');
 217     myStream.getline(Buffer,8192,'\n');
 218     for (Standard_Size lv = (strlen(Buffer)- 1); lv > 1 && (Buffer[lv] == '\r' || Buffer[lv] == '\n') ;lv--) {
 219       Buffer[lv] = '\0';
 220     }
 221
 222 //     if (myStream.get(c) && c != '\r' && c != '\n') {
 223 //       buffer += Buffer;
 224 //       buffer += c;
 225 //     }
 226 //     else {
 227       buffer += Buffer;
 228       IsEnd = Standard_True;
 229 //     }
 230   }
 231 }
 232
 233 //=======================================================================
 234 //function : WriteExtendedLine
 235 //purpose  : write from the current position to the end of line.
 236 //=======================================================================
 237
 238 void FSD_CmpFile::WriteExtendedLine(const TCollection_ExtendedString& buffer)
 239 {
 240 #if 0
 241   Standard_ExtString extBuffer;
 242   Standard_Integer   i,c,d;
 243
 244   extBuffer = buffer.ToExtString();
 245
 246   for (i = 0; i < buffer.Length(); i++) {
 247     c = (extBuffer[i] & 0x0000FF00 ) >> 8 ;
 248     d = extBuffer[i] & 0x000000FF;
 249
 250     myStream << (char)c << (char)d;
 251   }
 252
 253   myStream << (char)0 << "\n";
 254 #endif
 255   Standard_ExtString extBuffer;
 256   Standard_Integer   i;
 257
 258   extBuffer = buffer.ToExtString();
 259   PutInteger(buffer.Length());
 260   for (i = 0; i < buffer.Length(); i++) {
 261     PutExtCharacter(extBuffer[i]);
 262   }
 263
 264   myStream << "\n";
 265 }
 266
 267 //=======================================================================
 268 //function : ReadExtendedLine
 269 //purpose  :
 270 //=======================================================================
 271
 272 void FSD_CmpFile::ReadExtendedLine(TCollection_ExtendedString& buffer)
 273 {
 274   Standard_ExtCharacter c;
 275   Standard_Integer i;
 276
 277   GetInteger(i);
 278
 279   for (i = 0; i < buffer.Length(); i++) {
 280     GetExtCharacter(c);
 281     buffer += c;
 282   }
 283
 284   FlushEndOfLine();
 285 #if 0
 286   char c = '\0';
 287   Standard_ExtCharacter i = 0,j,count = 0;
 288   Standard_Boolean fin = Standard_False;
 289   Standard_CString tg = ENDOFNORMALEXTENDEDSECTION;
 290
 291   buffer.Clear();
 292
 293   while (!fin && !IsEnd()) {
 294     myStream.get(c);
 295
 296     if (c == tg[count]) count++;
 297     else count = 0;
 298     if (count < SIZEOFNORMALEXTENDEDSECTION) {
 299       i = 0; j = 0;
 300       i += (Standard_ExtCharacter)c;
 301       if (c == '\0') fin = Standard_True;
 302       i = (i << 8);
 303
 304       myStream.get(c);
 305       if (c == tg[count]) count++;
 306       else count = 0;
 307       if (count < SIZEOFNORMALEXTENDEDSECTION) {
 308         if ( c != '\r') {
 309           j += (Standard_ExtCharacter)c;
 310           if (c != '\n' && c != '\r') {
 311             fin = Standard_False;
 312             i |= (0x00FF & j);
 313             buffer += (Standard_ExtCharacter)i;
 314           }
 315
 316         }
 317       }
 318       else {
 319         Storage_StreamExtCharParityError::Raise();
 320       }
 321     }
 322     else {
 323       Storage_StreamExtCharParityError::Raise();
 324     }
 325   }
 326 #endif
 327
 328 }
 329
 330 //=======================================================================
 331 //function : ReadChar
 332 //purpose  : read <rsize> character from the current position.
 333 //=======================================================================
 334
 335 void FSD_CmpFile::ReadChar(TCollection_AsciiString& buffer, const Standard_Size rsize)
 336 {
 337   char             c;
 338   Standard_Size ccount = 0;
 339
 340   buffer.Clear();
 341
 342   while (!IsEnd() && (ccount < rsize)) {
 343     myStream.get(c);
 344     buffer += c;
 345     ccount++;
 346   }
 347 }
 348
 349 //=======================================================================
 350 //function : ReadString
 351 //purpose  : read from the first none space character position to the end of line.
 352 //=======================================================================
 353
 354 void FSD_CmpFile::ReadString(TCollection_AsciiString& buffer)
 355 {
 356   char Buffer[8193];
 357   char *bpos;
 358   Standard_Boolean IsEnd = Standard_False,isFirstTime = Standard_True;
 359
 360   buffer.Clear();
 361
 362   while (!IsEnd && !FSD_CmpFile::IsEnd()) {
 363     Buffer[0] = '\0';
 364     //myStream.get(Buffer,8192,'\n');
 365     myStream.getline(Buffer,8192,'\n');
 366     for (Standard_Size lv = (strlen(Buffer)- 1); lv > 1 && (Buffer[lv] == '\r' || Buffer[lv] == '\n') ;lv--) {
 367       Buffer[lv] = '\0';
 368     }
 369     bpos = Buffer;
 370
 371     // LeftAdjust
 372     //
 373     if (isFirstTime) {
 374       isFirstTime = Standard_False;
 375       while (*bpos == '\n' || *bpos == ' ') bpos++;
 376     }
 377 //     char c;
 378 //     if (myStream.get(c) && c != '\n') {
 379 //       buffer += bpos;
 380 //       buffer += c;
 381 //     }
 382 //     else {
 383       buffer += bpos;
 384       IsEnd = Standard_True;
 385 //     }
 386   }
 387 }
 388
 389 //=======================================================================
 390 //function : ReadWord
 391 //purpose  : read from the current position to the next white space or end of line.
 392 //=======================================================================
 393
 394 void FSD_CmpFile::ReadWord(TCollection_AsciiString& buffer)
 395 {
 396   char c;
 397   char b[8193],*tmpb;
 398   Standard_Boolean IsEnd = Standard_False;
 399   Standard_Integer i;
 400
 401   tmpb = b;
 402   memset(b,'\0',8193);
 403   buffer.Clear();
 404
 405   while (!IsEnd && !FSD_CmpFile::IsEnd()) {
 406     myStream.get(c);
 407     if ((c != ' ') && (c != '\n')) IsEnd = Standard_True;
 408   }
 409
 410   IsEnd = Standard_False;
 411   i = 0;
 412
 413   while (!IsEnd && !FSD_CmpFile::IsEnd()) {
 414     if (i == 8192) {
 415       buffer += b;
 416       tmpb = b;
 417       memset(b,'\0',8193);
 418       i = 0;
 419     }
 420     *tmpb = c;
 421     tmpb++; i++;
 422     myStream.get(c);
 423     if ((c == '\n') || (c == ' ')) IsEnd = Standard_True;
 424   }
 425
 426   buffer += b;
 427 }
 428
 429 //=======================================================================
 430 //function : FindTag
 431 //purpose  :
 432 //=======================================================================
 433
 434 Storage_Error FSD_CmpFile::FindTag(const Standard_CString aTag)
 435 {
 436   TCollection_AsciiString l;
 437
 438   ReadString(l);
 439
 440   while ((strcmp(l.ToCString(),aTag) != 0) && !IsEnd()) {
 441     ReadString(l);
 442   }
 443
 444   if (IsEnd()) {
 445     return Storage_VSSectionNotFound;
 446   }
 447   else {
 448     return Storage_VSOk;
 449   }
 450 }
 451
 452 //=======================================================================
 453 //function : SkipObject
 454 //purpose  :
 455 //=======================================================================
 456
 457 void FSD_CmpFile::SkipObject()
 458 {
 459   FlushEndOfLine();
 460 }
 461
 462 //=======================================================================
 463 //function : PutReference
 464 //purpose  : ---------------------- PUBLIC : PUT
 465 //=======================================================================
 466
 467 Storage_BaseDriver& FSD_CmpFile::PutReference(const Standard_Integer aValue)
 468 {
 469   myStream << aValue << " ";
 470   if (myStream.bad()) Storage_StreamWriteError::Raise();
 471   return *this;
 472 }
 473
 474 //=======================================================================
 475 //function : PutCharacter
 476 //purpose  :
 477 //=======================================================================
 478
 479 Storage_BaseDriver& FSD_CmpFile::PutCharacter(const Standard_Character aValue)
 480 {
 481   unsigned short i;
 482
 483   i = aValue;
 484   myStream << i << " ";
 485   if (myStream.bad()) Storage_StreamWriteError::Raise();
 486   return *this;
 487 }
 488
 489 //=======================================================================
 490 //function : PutExtCharacter
 491 //purpose  :
 492 //=======================================================================
 493
 494 Storage_BaseDriver& FSD_CmpFile::PutExtCharacter(const Standard_ExtCharacter aValue)
 495 {
 496   myStream << aValue << " ";
 497   if (myStream.bad()) Storage_StreamWriteError::Raise();
 498   return *this;
 499 }
 500
 501 //=======================================================================
 502 //function : PutInteger
 503 //purpose  :
 504 //=======================================================================
 505
 506 Storage_BaseDriver& FSD_CmpFile::PutInteger(const Standard_Integer aValue)
 507 {
 508   myStream << aValue << " ";
 509   if (myStream.bad()) Storage_StreamWriteError::Raise();
 510   return *this;
 511 }
 512
 513 //=======================================================================
 514 //function : PutBoolean
 515 //purpose  :
 516 //=======================================================================
 517
 518 Storage_BaseDriver& FSD_CmpFile::PutBoolean(const Standard_Boolean aValue)
 519 {
 520   myStream << ((Standard_Integer)aValue) << " ";
 521   if (myStream.bad()) Storage_StreamWriteError::Raise();
 522   return *this;
 523 }
 524
 525 //=======================================================================
 526 //function : PutReal
 527 //purpose  :
 528 //=======================================================================
 529
 530 Storage_BaseDriver& FSD_CmpFile::PutReal(const Standard_Real aValue)
 531 {
 532 #ifdef BUC60808
 533   char realbuffer[100];
 534   Standard_PCharacter pChar;
 535   //
 536   pChar=realbuffer;
 537   realbuffer[0] = '\0';
 538   //
 539   if (myRealConv.RealToCString(aValue,pChar)) {
 540     myStream << realbuffer << " ";
 541   }
 542   else {
 543     Storage_StreamWriteError::Raise();
 544   }
 545   if (myStream.bad()) Storage_StreamWriteError::Raise();
 546
 547   return *this;
 548
 549 #else
 550   myStream << ((Standard_Real)aValue) << " ";
 551
 552   if (myStream.bad()) Storage_StreamWriteError::Raise();
 553   return *this;
 554 #endif
 555 }
 556
 557 //=======================================================================
 558 //function : PutShortReal
 559 //purpose  :
 560 //=======================================================================
 561
 562 Storage_BaseDriver& FSD_CmpFile::PutShortReal(const Standard_ShortReal aValue)
 563 {
 564 #ifdef BUC60808
 565   char realbuffer[100];
 566   Standard_PCharacter pStr;
 567   //
 568   pStr=realbuffer;
 569   realbuffer[0] = '\0';
 570   //
 571   if (myRealConv.RealToCString(aValue,pStr)) {
 572     myStream << realbuffer << " ";
 573   }
 574   else {
 575     Storage_StreamWriteError::Raise();
 576   }
 577   if (myStream.bad()) Storage_StreamWriteError::Raise();
 578
 579   return *this;
 580 #else
 581   myStream << aValue << " ";
 582
 583   if (myStream.bad()) Storage_StreamWriteError::Raise();
 584   return *this;
 585 #endif
 586 }
 587
 588 //=======================================================================
 589 //function : GetReference
 590 //purpose  : ----------------- PUBLIC : GET
 591 //=======================================================================
 592
 593 Storage_BaseDriver& FSD_CmpFile::GetReference(Standard_Integer& aValue)
 594 {
 595   if (!(myStream >> aValue)) Storage_StreamTypeMismatchError::Raise();
 596
 597   return *this;
 598 }
 599
 600 //=======================================================================
 601 //function : GetCharacter
 602 //purpose  :
 603 //=======================================================================
 604
 605 Storage_BaseDriver& FSD_CmpFile::GetCharacter(Standard_Character& aValue)
 606 {
 607   unsigned short i = 0;
 608   if (!(myStream >> i)) {
 609     // SGI : donne une erreur mais a une bonne valeur pour les caracteres ecrits
 610     //       signes (-80 fait ios::badbit, mais la variable i est initialisee)
 611     //
 612     if (i == 0) Storage_StreamTypeMismatchError::Raise();
 613     myStream.clear(ios::goodbit);
 614   }
 615   aValue = (char)i;
 616
 617   return *this;
 618 }
 619
 620 //=======================================================================
 621 //function : GetExtCharacter
 622 //purpose  :
 623 //=======================================================================
 624
 625 Storage_BaseDriver& FSD_CmpFile::GetExtCharacter(Standard_ExtCharacter& aValue)
 626 {
 627   if (!(myStream >> aValue)) Storage_StreamTypeMismatchError::Raise();
 628
 629   return *this;
 630 }
 631
 632 //=======================================================================
 633 //function : GetInteger
 634 //purpose  :
 635 //=======================================================================
 636
 637 Storage_BaseDriver& FSD_CmpFile::GetInteger(Standard_Integer& aValue)
 638 {
 639   if (!(myStream >> aValue)) Storage_StreamTypeMismatchError::Raise();
 640
 641   return *this;
 642 }
 643
 644 //=======================================================================
 645 //function : GetBoolean
 646 //purpose  :
 647 //=======================================================================
 648
 649 Storage_BaseDriver& FSD_CmpFile::GetBoolean(Standard_Boolean& aValue)
 650 {
 651   if (!(myStream >> aValue)) Storage_StreamTypeMismatchError::Raise();
 652
 653   return *this;
 654 }
 655
 656 //=======================================================================
 657 //function : GetReal
 658 //purpose  :
 659 //=======================================================================
 660
 661 Storage_BaseDriver& FSD_CmpFile::GetReal(Standard_Real& aValue)
 662 {
 663 #ifdef BUC60808
 664   char realbuffer[100];
 665
 666   realbuffer[0] = '\0';
 667   if (!(myStream >> realbuffer)) {
 668     cerr << "%%%ERROR: read error of double at offset " << myStream.tellg() << endl;
 669     cerr << "\t buffer is" << realbuffer<< endl;
 670     Storage_StreamTypeMismatchError::Raise();
 671   }
 672   if (!myRealConv.CStringToReal(realbuffer,aValue)) {
 673     cerr << "%%%ERROR: read error of double at offset " << myStream.tellg() << endl;
 674     cerr << "\t buffer is" << realbuffer<< endl;
 675     //if (!OSD::CStringToReal(realbuffer,aValue))
 676     Storage_StreamTypeMismatchError::Raise();
 677   }
 678
 679   return *this;
 680 #else
 681   if (!(myStream >> aValue)) Storage_StreamTypeMismatchError::Raise();
 682
 683   return *this;
 684 #endif
 685 }
 686
 687 //=======================================================================
 688 //function : GetShortReal
 689 //purpose  :
 690 //=======================================================================
 691
 692 Storage_BaseDriver& FSD_CmpFile::GetShortReal(Standard_ShortReal& aValue)
 693 {
 694 #ifdef BUC60808
 695   char realbuffer[100];
 696   Standard_Real r = 0.0;
 697
 698   realbuffer[0] = '\0';
 699   if (!(myStream >> realbuffer)) Storage_StreamTypeMismatchError::Raise();
 700   // if (!OSD::CStringToReal(realbuffer,r))
 701   if (!myRealConv.CStringToReal(realbuffer,r))  Storage_StreamTypeMismatchError::Raise();
 702
 703   aValue = (Standard_ShortReal)r;
 704
 705   return *this;
 706 #else
 707   if (!(myStream >> aValue)) Storage_StreamTypeMismatchError::Raise();
 708  return *this;
 709 #endif
 710 }
 711
 712 //=======================================================================
 713 //function : Destroy
 714 //purpose  :
 715 //=======================================================================
 716
 717 void FSD_CmpFile::Destroy()
 718 {
 719   if (OpenMode() != Storage_VSNone) {
 720     Close();
 721   }
 722 }
 723
 724 //=======================================================================
 725 //function : BeginWriteInfoSection
 726 //purpose  : -------------------------- INFO : WRITE
 727 //=======================================================================
 728
 729 Storage_Error FSD_CmpFile::BeginWriteInfoSection()
 730 {
 731   myStream << FSD_CmpFile::MagicNumber() << '\n';
 732   myStream << "BEGIN_INFO_SECTION\n";
 733   if (myStream.bad()) Storage_StreamWriteError::Raise();
 734
 735   return Storage_VSOk;
 736 }
 737
 738 //=======================================================================
 739 //function : WriteInfo
 740 //purpose  :
 741 //=======================================================================
 742
 743 void FSD_CmpFile::WriteInfo(const Standard_Integer nbObj,
 744                          const TCollection_AsciiString& dbVersion,
 745                          const TCollection_AsciiString& date,
 746                          const TCollection_AsciiString& schemaName,
 747                          const TCollection_AsciiString& schemaVersion,
 748                          const TCollection_ExtendedString& appName,
 749                          const TCollection_AsciiString& appVersion,
 750                          const TCollection_ExtendedString& dataType,
 751                          const TColStd_SequenceOfAsciiString& userInfo)
 752 {
 753   Standard_Integer i;
 754
 755   myStream << nbObj;
 756   myStream << "\n";
 757   myStream << dbVersion.ToCString() << "\n";
 758   myStream << date.ToCString() << "\n";
 759   myStream << schemaName.ToCString() << "\n";
 760   myStream << schemaVersion.ToCString() << "\n";
 761   WriteExtendedLine(appName);
 762   myStream << appVersion.ToCString() << "\n";
 763   WriteExtendedLine(dataType);
 764   myStream << userInfo.Length() << "\n";
 765
 766   if (myStream.bad()) Storage_StreamWriteError::Raise();
 767
 768   for (i = 1; i <= userInfo.Length(); i++) {
 769     myStream << userInfo.Value(i).ToCString() << "\n";
 770     if (myStream.bad()) Storage_StreamWriteError::Raise();
 771   }
 772 }
 773
 774 //=======================================================================
 775 //function : EndWriteInfoSection
 776 //purpose  : read
 777 //=======================================================================
 778
 779 Storage_Error FSD_CmpFile::EndWriteInfoSection()
 780 {
 781   myStream << "END_INFO_SECTION\n";
 782   if (myStream.bad())  Storage_StreamWriteError::Raise();
 783   return Storage_VSOk;
 784 }
 785
 786 //=======================================================================
 787 //function : BeginReadInfoSection
 788 //purpose  :
 789 //=======================================================================
 790
 791 Storage_Error FSD_CmpFile::BeginReadInfoSection()
 792 {
 793   Storage_Error s;
 794   TCollection_AsciiString l;
 795   Standard_Size        len = strlen(FSD_CmpFile::MagicNumber());
 796
 797   ReadChar(l,len);
 798
 799   if (strncmp(FSD_CmpFile::MagicNumber(),l.ToCString(),len) != 0) {
 800     s = Storage_VSFormatError;
 801   }
 802   else {
 803     s = FindTag("BEGIN_INFO_SECTION");
 804   }
 805
 806   return s;
 807 }
 808
 809 //=======================================================================
 810 //function : ReadInfo
 811 //purpose  : ------------------- INFO : READ
 812 //=======================================================================
 813
 814 void FSD_CmpFile::ReadInfo(Standard_Integer& nbObj,
 815                         TCollection_AsciiString& dbVersion,
 816                         TCollection_AsciiString& date,
 817                         TCollection_AsciiString& schemaName,
 818                         TCollection_AsciiString& schemaVersion,
 819                         TCollection_ExtendedString& appName,
 820                         TCollection_AsciiString& appVersion,
 821                         TCollection_ExtendedString& dataType,
 822                         TColStd_SequenceOfAsciiString& userInfo)
 823 {
 824   if (!(myStream >> nbObj)) Storage_StreamTypeMismatchError::Raise();
 825
 826   FlushEndOfLine();
 827
 828   ReadLine(dbVersion);
 829   ReadLine(date);
 830   ReadLine(schemaName);
 831   ReadLine(schemaVersion);
 832   ReadExtendedLine(appName);
 833   ReadLine(appVersion);
 834   ReadExtendedLine(dataType);
 835
 836   Standard_Integer i,len = 0;
 837
 838   if (!(myStream >> len)) Storage_StreamTypeMismatchError::Raise();
 839
 840   FlushEndOfLine();
 841
 842   TCollection_AsciiString line;
 843
 844   for (i = 1; i <= len && !IsEnd(); i++) {
 845     ReadLine(line);
 846     userInfo.Append(line);
 847     line.Clear();
 848   }
 849 }
 850
 851 //=======================================================================
 852 //function : EndReadInfoSection
 853 //purpose  : COMMENTS SECTION
 854 //           write
 855 //=======================================================================
 856
 857 Storage_Error FSD_CmpFile::EndReadInfoSection()
 858 {
 859   return FindTag("END_INFO_SECTION");
 860 }
 861
 862 //=======================================================================
 863 //function : BeginWriteCommentSection
 864 //purpose  : ---------------- COMMENTS : WRITE
 865 //=======================================================================
 866
 867 Storage_Error FSD_CmpFile::BeginWriteCommentSection()
 868 {
 869   myStream << "BEGIN_COMMENT_SECTION\n";
 870   if (myStream.bad()) Storage_StreamWriteError::Raise();
 871   return Storage_VSOk;
 872 }
 873
 874 //=======================================================================
 875 //function : WriteComment
 876 //purpose  :
 877 //=======================================================================
 878
 879 void FSD_CmpFile::WriteComment(const TColStd_SequenceOfExtendedString& aCom)
 880 {
 881  Standard_Integer i,aSize;
 882
 883  aSize = aCom.Length();
 884  myStream << aSize << "\n";
 885  if (myStream.bad()) Storage_StreamWriteError::Raise();
 886
 887  for (i = 1; i <= aSize; i++) {
 888    WriteExtendedLine(aCom.Value(i));
 889    if (myStream.bad()) Storage_StreamWriteError::Raise();
 890  }
 891 }
 892
 893 //=======================================================================
 894 //function : EndWriteCommentSection
 895 //purpose  : read
 896 //=======================================================================
 897
 898 Storage_Error FSD_CmpFile::EndWriteCommentSection()
 899 {
 900   myStream << "END_COMMENT_SECTION\n";
 901   if (myStream.bad()) Storage_StreamWriteError::Raise();
 902   return Storage_VSOk;
 903 }
 904
 905 //=======================================================================
 906 //function : BeginReadCommentSection
 907 //purpose  : ---------------- COMMENTS : READ
 908 //=======================================================================
 909
 910 Storage_Error FSD_CmpFile::BeginReadCommentSection()
 911 {
 912   return FindTag("BEGIN_COMMENT_SECTION");
 913 }
 914
 915 //=======================================================================
 916 //function : ReadComment
 917 //purpose  :
 918 //=======================================================================
 919
 920 void FSD_CmpFile::ReadComment(TColStd_SequenceOfExtendedString& aCom)
 921 {
 922   TCollection_ExtendedString line;
 923   Standard_Integer           len,i;
 924
 925   if (!(myStream >> len)) Storage_StreamTypeMismatchError::Raise();
 926
 927   FlushEndOfLine();
 928
 929   for (i = 1; i <= len && !IsEnd(); i++) {
 930     ReadExtendedLine(line);
 931     aCom.Append(line);
 932     line.Clear();
 933   }
 934 }
 935
 936 //=======================================================================
 937 //function : EndReadCommentSection
 938 //purpose  :
 939 //=======================================================================
 940
 941 Storage_Error FSD_CmpFile::EndReadCommentSection()
 942 {
 943   return FindTag("END_COMMENT_SECTION");
 944 }
 945
 946 //=======================================================================
 947 //function : BeginWriteTypeSection
 948 //purpose  : --------------- TYPE : WRITE
 949 //=======================================================================
 950
 951 Storage_Error FSD_CmpFile::BeginWriteTypeSection()
 952 {
 953   myStream << "BEGIN_TYPE_SECTION\n";
 954   if (myStream.bad()) Storage_StreamWriteError::Raise();
 955   return Storage_VSOk;
 956 }
 957
 958 //=======================================================================
 959 //function : SetTypeSectionSize
 960 //purpose  :
 961 //=======================================================================
 962
 963 void FSD_CmpFile::SetTypeSectionSize(const Standard_Integer aSize)
 964 {
 965   myStream << aSize << "\n";
 966   if (myStream.bad()) Storage_StreamWriteError::Raise();
 967 }
 968
 969 //=======================================================================
 970 //function : WriteTypeInformations
 971 //purpose  :
 972 //=======================================================================
 973
 974 void FSD_CmpFile::WriteTypeInformations(const Standard_Integer typeNum,
 975                                       const TCollection_AsciiString& typeName)
 976 {
 977   myStream << typeNum << " " << typeName.ToCString() << "\n";
 978   if (myStream.bad()) Storage_StreamWriteError::Raise();
 979 }
 980
 981 //=======================================================================
 982 //function : EndWriteTypeSection
 983 //purpose  : read
 984 //=======================================================================
 985
 986 Storage_Error FSD_CmpFile::EndWriteTypeSection()
 987 {
 988   myStream << "END_TYPE_SECTION\n";
 989   if (myStream.bad()) Storage_StreamWriteError::Raise();
 990   return Storage_VSOk;
 991 }
 992
 993 //=======================================================================
 994 //function : BeginReadTypeSection
 995 //purpose  : ------------------- TYPE : READ
 996 //=======================================================================
 997
 998 Storage_Error FSD_CmpFile::BeginReadTypeSection()
 999 {
1000   return FindTag("BEGIN_TYPE_SECTION");
1001 }
1002
1003 //=======================================================================
1004 //function : TypeSectionSize
1005 //purpose  :
1006 //=======================================================================
1007
1008 Standard_Integer FSD_CmpFile::TypeSectionSize()
1009 {
1010   Standard_Integer i;
1011
1012   if (!(myStream >> i)) Storage_StreamTypeMismatchError::Raise();
1013
1014   FlushEndOfLine();
1015
1016   return i;
1017 }
1018
1019 //=======================================================================
1020 //function : ReadTypeInformations
1021 //purpose  :
1022 //=======================================================================
1023
1024 void FSD_CmpFile::ReadTypeInformations(Standard_Integer& typeNum,
1025                                     TCollection_AsciiString& typeName)
1026 {
1027   if (!(myStream >> typeNum)) Storage_StreamTypeMismatchError::Raise();
1028   if (!(myStream >> typeName)) Storage_StreamTypeMismatchError::Raise();
1029   FlushEndOfLine();
1030 }
1031
1032 //=======================================================================
1033 //function : EndReadTypeSection
1034 //purpose  : ROOT SECTION
1035 //           write
1036 //=======================================================================
1037
1038 Storage_Error FSD_CmpFile::EndReadTypeSection()
1039 {
1040   return FindTag("END_TYPE_SECTION");
1041 }
1042
1043 //=======================================================================
1044 //function : BeginWriteRootSection
1045 //purpose  : -------------------- ROOT : WRITE
1046 //=======================================================================
1047
1048 Storage_Error FSD_CmpFile::BeginWriteRootSection()
1049 {
1050   myStream << "BEGIN_ROOT_SECTION\n";
1051   if (myStream.bad()) Storage_StreamWriteError::Raise();
1052   return Storage_VSOk;
1053 }
1054
1055 //=======================================================================
1056 //function : SetRootSectionSize
1057 //purpose  :
1058 //=======================================================================
1059
1060 void FSD_CmpFile::SetRootSectionSize(const Standard_Integer aSize)
1061 {
1062   myStream << aSize << "\n";
1063   if (myStream.bad()) Storage_StreamWriteError::Raise();
1064 }
1065
1066 //=======================================================================
1067 //function : WriteRoot
1068 //purpose  :
1069 //=======================================================================
1070
1071 void FSD_CmpFile::WriteRoot(const TCollection_AsciiString& rootName, const Standard_Integer aRef, const TCollection_AsciiString& rootType)
1072 {
1073   myStream << aRef << " " << rootName.ToCString() << " " << rootType.ToCString() << "\n";
1074   if (myStream.bad()) Storage_StreamWriteError::Raise();
1075 }
1076
1077 //=======================================================================
1078 //function : EndWriteRootSection
1079 //purpose  : read
1080 //=======================================================================
1081
1082 Storage_Error FSD_CmpFile::EndWriteRootSection()
1083 {
1084   myStream << "END_ROOT_SECTION\n";
1085   if (myStream.bad()) Storage_StreamWriteError::Raise();
1086   return Storage_VSOk;
1087 }
1088
1089 //=======================================================================
1090 //function : BeginReadRootSection
1091 //purpose  : ----------------------- ROOT : READ
1092 //=======================================================================
1093
1094 Storage_Error FSD_CmpFile::BeginReadRootSection()
1095 {
1096   return FindTag("BEGIN_ROOT_SECTION");
1097 }
1098
1099 //=======================================================================
1100 //function : RootSectionSize
1101 //purpose  :
1102 //=======================================================================
1103
1104 Standard_Integer FSD_CmpFile::RootSectionSize()
1105 {
1106   Standard_Integer i;
1107
1108   if (!(myStream >> i)) Storage_StreamTypeMismatchError::Raise();
1109
1110   FlushEndOfLine();
1111
1112   return i;
1113 }
1114
1115 //=======================================================================
1116 //function : ReadRoot
1117 //purpose  :
1118 //=======================================================================
1119
1120 void FSD_CmpFile::ReadRoot(TCollection_AsciiString& rootName, Standard_Integer& aRef,TCollection_AsciiString& rootType)
1121 {
1122   if (!(myStream >> aRef)) Storage_StreamTypeMismatchError::Raise();
1123   ReadWord(rootName);
1124   ReadWord(rootType);
1125 }
1126
1127 //=======================================================================
1128 //function : EndReadRootSection
1129 //purpose  : REF SECTION
1130 //           write
1131 //=======================================================================
1132
1133 Storage_Error FSD_CmpFile::EndReadRootSection()
1134 {
1135   return FindTag("END_ROOT_SECTION");
1136 }
1137
1138 //=======================================================================
1139 //function : BeginWriteRefSection
1140 //purpose  : -------------------------- REF : WRITE
1141 //=======================================================================
1142
1143 Storage_Error FSD_CmpFile::BeginWriteRefSection()
1144 {
1145   myStream << "BEGIN_REF_SECTION\n";
1146   if (myStream.bad()) Storage_StreamWriteError::Raise();
1147   return Storage_VSOk;
1148 }
1149
1150 //=======================================================================
1151 //function : SetRefSectionSize
1152 //purpose  :
1153 //=======================================================================
1154
1155 void FSD_CmpFile::SetRefSectionSize(const Standard_Integer aSize)
1156 {
1157   myStream << aSize << "\n";
1158   if (myStream.bad()) Storage_StreamWriteError::Raise();
1159 }
1160
1161 //=======================================================================
1162 //function : WriteReferenceType
1163 //purpose  :
1164 //=======================================================================
1165
1166 void FSD_CmpFile::WriteReferenceType(const Standard_Integer reference,
1167                                   const Standard_Integer typeNum)
1168 {
1169   myStream << reference << " " << typeNum << "\n";
1170   if (myStream.bad()) Storage_StreamWriteError::Raise();
1171 }
1172
1173 //=======================================================================
1174 //function : EndWriteRefSection
1175 //purpose  : read
1176 //=======================================================================
1177
1178 Storage_Error FSD_CmpFile::EndWriteRefSection()
1179 {
1180   myStream << "END_REF_SECTION\n";
1181   if (myStream.bad()) Storage_StreamWriteError::Raise();
1182   return Storage_VSOk;
1183 }
1184
1185 //=======================================================================
1186 //function : BeginReadRefSection
1187 //purpose  : ----------------------- REF : READ
1188 //=======================================================================
1189
1190 Storage_Error FSD_CmpFile::BeginReadRefSection()
1191 {
1192   return FindTag("BEGIN_REF_SECTION");
1193 }
1194
1195 //=======================================================================
1196 //function : RefSectionSize
1197 //purpose  :
1198 //=======================================================================
1199
1200 Standard_Integer FSD_CmpFile::RefSectionSize()
1201 {
1202   Standard_Integer i;
1203
1204   if (!(myStream >> i)) Storage_StreamTypeMismatchError::Raise();
1205   FlushEndOfLine();
1206
1207   return i;
1208 }
1209
1210 //=======================================================================
1211 //function : ReadReferenceType
1212 //purpose  :
1213 //=======================================================================
1214
1215 void FSD_CmpFile::ReadReferenceType(Standard_Integer& reference,
1216                                  Standard_Integer& typeNum)
1217 {
1218   if (!(myStream >> reference)) Storage_StreamTypeMismatchError::Raise();
1219   if (!(myStream >> typeNum)) Storage_StreamTypeMismatchError::Raise();
1220   FlushEndOfLine();
1221 }
1222
1223 //=======================================================================
1224 //function : EndReadRefSection
1225 //purpose  : DATA SECTION
1226 //           write
1227 //=======================================================================
1228
1229 Storage_Error FSD_CmpFile::EndReadRefSection()
1230 {
1231   return FindTag("END_REF_SECTION");
1232 }
1233
1234 //=======================================================================
1235 //function : BeginWriteDataSection
1236 //purpose  : -------------------- DATA : WRITE
1237 //=======================================================================
1238
1239 Storage_Error FSD_CmpFile::BeginWriteDataSection()
1240 {
1241   myStream << "BEGIN_DATA_SECTION";
1242   if (myStream.bad()) Storage_StreamWriteError::Raise();
1243   return Storage_VSOk;
1244 }
1245
1246 //=======================================================================
1247 //function : WritePersistentObjectHeader
1248 //purpose  :
1249 //=======================================================================
1250
1251 void FSD_CmpFile::WritePersistentObjectHeader(const Standard_Integer aRef,
1252                                            const Standard_Integer aType)
1253 {
1254   myStream << "\n#" << aRef << "%" << aType << " ";
1255   if (myStream.bad()) Storage_StreamWriteError::Raise();
1256 }
1257
1258 //=======================================================================
1259 //function : BeginWritePersistentObjectData
1260 //purpose  :
1261 //=======================================================================
1262
1263 void FSD_CmpFile::BeginWritePersistentObjectData()
1264 {
1265   if (myStream.bad()) Storage_StreamWriteError::Raise();
1266 }
1267
1268 //=======================================================================
1269 //function : BeginWriteObjectData
1270 //purpose  :
1271 //=======================================================================
1272
1273 void FSD_CmpFile::BeginWriteObjectData()
1274 {
1275   if (myStream.bad()) Storage_StreamWriteError::Raise();
1276 }
1277
1278 //=======================================================================
1279 //function : EndWriteObjectData
1280 //purpose  :
1281 //=======================================================================
1282
1283 void FSD_CmpFile::EndWriteObjectData()
1284 {
1285   if (myStream.bad()) Storage_StreamWriteError::Raise();
1286 }
1287
1288 //=======================================================================
1289 //function : EndWritePersistentObjectData
1290 //purpose  :
1291 //=======================================================================
1292
1293 void FSD_CmpFile::EndWritePersistentObjectData()
1294 {
1295   if (myStream.bad()) Storage_StreamWriteError::Raise();
1296 }
1297
1298 //=======================================================================
1299 //function : EndWriteDataSection
1300 //purpose  : read
1301 //=======================================================================
1302
1303 Storage_Error FSD_CmpFile::EndWriteDataSection()
1304 {
1305   myStream << "\nEND_DATA_SECTION\n";
1306   if (myStream.bad()) Storage_StreamWriteError::Raise();
1307   return Storage_VSOk;
1308 }
1309
1310 //=======================================================================
1311 //function : BeginReadDataSection
1312 //purpose  : ---------------------- DATA : READ
1313 //=======================================================================
1314
1315 Storage_Error FSD_CmpFile::BeginReadDataSection()
1316 {
1317   return FindTag("BEGIN_DATA_SECTION");
1318 }
1319
1320 //=======================================================================
1321 //function : ReadPersistentObjectHeader
1322 //purpose  :
1323 //=======================================================================
1324
1325 void FSD_CmpFile::ReadPersistentObjectHeader(Standard_Integer& aRef,
1326                                           Standard_Integer& aType)
1327 {
1328   char c;
1329
1330   myStream.get(c);
1331
1332   while (c != '#') {
1333     if (IsEnd() || (c != ' ') || (c == '\r')|| (c == '\n')) {
1334       Storage_StreamFormatError::Raise();
1335     }
1336     myStream.get(c);
1337   }
1338
1339   if (!(myStream >> aRef)) Storage_StreamTypeMismatchError::Raise();
1340
1341   myStream.get(c);
1342
1343   while (c != '%') {
1344     if (IsEnd() || (c != ' ') || (c == '\r')|| (c == '\n')) {
1345       Storage_StreamFormatError::Raise();
1346     }
1347     myStream.get(c);
1348   }
1349
1350   if (!(myStream >> aType)) Storage_StreamTypeMismatchError::Raise();
1351 //  cout << "REF:" << aRef << " TYPE:"<< aType << endl;
1352 }
1353
1354 //=======================================================================
1355 //function : BeginReadPersistentObjectData
1356 //purpose  :
1357 //=======================================================================
1358
1359 void FSD_CmpFile::BeginReadPersistentObjectData()
1360 {
1361 //cout << "BeginReadPersistentObjectData" << endl;
1362 }
1363
1364 //=======================================================================
1365 //function : BeginReadObjectData
1366 //purpose  :
1367 //=======================================================================
1368
1369 void FSD_CmpFile::BeginReadObjectData()
1370 {
1371 //  cout << "BeginReadObjectData" << endl;
1372 }
1373
1374 //=======================================================================
1375 //function : EndReadObjectData
1376 //purpose  :
1377 //=======================================================================
1378
1379 void FSD_CmpFile::EndReadObjectData()
1380 {
1381 //  cout << "EndReadObjectData" << endl;
1382 }
1383
1384 //=======================================================================
1385 //function : EndReadPersistentObjectData
1386 //purpose  :
1387 //=======================================================================
1388
1389 void FSD_CmpFile::EndReadPersistentObjectData()
1390 {
1391   char c;
1392
1393   myStream.get(c);
1394   while (c != '\n' && (c != '\r')) {
1395     if (IsEnd() || (c != ' ')) {
1396       Storage_StreamFormatError::Raise();
1397     }
1398     myStream.get(c);
1399   }
1400  if (c == '\r') {
1401    myStream.get(c);
1402  }
1403 //  cout << "EndReadPersistentObjectData" << endl;
1404 }
1405
1406 //=======================================================================
1407 //function : EndReadDataSection
1408 //purpose  :
1409 //=======================================================================
1410
1411 Storage_Error FSD_CmpFile::EndReadDataSection()
1412 {
1413   return FindTag("END_DATA_SECTION");
1414 }
1415
1416 //=======================================================================
1417 //function : Tell
1418 //purpose  : return position in the file. Return -1 upon error.
1419 //=======================================================================
1420
1421 Storage_Position FSD_CmpFile::Tell()
1422 {
1423   switch (OpenMode()) {
1424   case Storage_VSRead:
1425     return (Storage_Position) myStream.tellp();
1426   case Storage_VSWrite:
1427     return (Storage_Position) myStream.tellg();
1428   case Storage_VSReadWrite: {
1429     Storage_Position aPosR  = (Storage_Position) myStream.tellp();
1430     Storage_Position aPosW  = (Storage_Position) myStream.tellg();
1431     if (aPosR < aPosW)
1432       return aPosW;
1433     else
1434       return aPosR;
1435   }
1436   default: return -1;
1437   }
1438   return -1;
1439 }