0031668: Visualization - WebGL sample doesn't work on Emscripten 1.39
[occt.git] / src / BinObjMgt / BinObjMgt_Persistent.cxx
1 // Created on: 2002-10-30
2 // Created by: Michael SAZONOV
3 // Copyright (c) 2002-2014 OPEN CASCADE SAS
4 //
5 // This file is part of Open CASCADE Technology software library.
6 //
7 // This library is free software; you can redistribute it and/or modify it under
8 // the terms of the GNU Lesser General Public License version 2.1 as published
9 // by the Free Software Foundation, with special exception defined in the file
10 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
11 // distribution for complete text of the license and disclaimer of any warranty.
12 //
13 // Alternatively, this file may be used under the terms of Open CASCADE
14 // commercial license or contractual agreement.
15
16
17 #include <BinObjMgt_Persistent.hxx>
18 #include <FSD_FileHeader.hxx>
19 #include <Standard_GUID.hxx>
20 #include <TCollection_AsciiString.hxx>
21 #include <TCollection_ExtendedString.hxx>
22 #include <TColStd_ListIteratorOfListOfInteger.hxx>
23 #include <TColStd_ListOfInteger.hxx>
24 #include <TDF_Data.hxx>
25 #include <TDF_Label.hxx>
26 #include <TDF_Tool.hxx>
27 #include <FSD_BinaryFile.hxx>
28
29 #define BP_INTSIZE         ((Standard_Integer)sizeof(Standard_Integer))
30 #define BP_EXTCHARSIZE     ((Standard_Integer)sizeof(Standard_ExtCharacter))
31 #define BP_REALSIZE        ((Standard_Integer)sizeof(Standard_Real))
32 #define BP_SHORTREALSIZE   ((Standard_Integer)sizeof(Standard_ShortReal))
33 #define BP_UUIDSIZE        ((Standard_Integer)sizeof(BinObjMgt_UUID))
34
35 // We define a GUID structure that is different from Standard_UUID because
36 // the latter contains a 'unsigned long' member that has variables size
37 // (4 or 8 bits) thus making the persistent files non-portable.
38 // This structure below ensures the portability.
39 typedef struct {
40   unsigned int   Data1 ;        // 4-bytes long on all OS
41   unsigned short Data2 ;        // 2-bytes long on all OS
42   unsigned short Data3 ;        // 2-bytes long on all OS
43   unsigned char  Data4[8] ;     // 8-bytes long on all OS
44 } BinObjMgt_UUID ;
45
46 //=======================================================================
47 //function : BinObjMgt_Persistent
48 //purpose  : Empty constructor
49 //=======================================================================
50
51 BinObjMgt_Persistent::BinObjMgt_Persistent ()
52      : myIndex (1),
53        myOffset(BP_HEADSIZE),
54        mySize  (BP_HEADSIZE),
55        myIsError (Standard_False)
56 {
57   Init();
58 }
59
60 //=======================================================================
61 //function : Init
62 //purpose  : Initializes me to reuse again
63 //=======================================================================
64
65 void BinObjMgt_Persistent::Init ()
66 {
67   if (myData.IsEmpty()) {
68     Standard_Address aPiece = Standard::Allocate (BP_PIECESIZE);
69     myData.Append (aPiece);
70   }
71   Standard_Integer *aData = (Standard_Integer*) myData(1);
72   aData[0] = 0;         // Type Id
73   aData[1] = 0;         // Object Id
74   aData[2] = 0;         // Data length
75   myIndex = 1;
76   myOffset = BP_HEADSIZE;
77   mySize = BP_HEADSIZE;
78   myIsError = Standard_False;
79 }
80
81 //=======================================================================
82 //function : Write
83 //purpose  : Stores <me> to the stream.
84 //           inline Standard_OStream& operator<< (Standard_OStream&,
85 //           const BinObjMgt_Persistent&) is also available
86 //=======================================================================
87
88 Standard_OStream& BinObjMgt_Persistent::Write (Standard_OStream& theOS)
89 {
90   Standard_Integer nbWritten = 0;
91   Standard_Integer *aData = (Standard_Integer*) myData(1);
92   // update data length
93   aData[2] = mySize - BP_HEADSIZE;
94 #if DO_INVERSE
95   aData[0] = InverseInt (aData[0]);
96   aData[1] = InverseInt (aData[1]);
97   aData[2] = InverseInt (aData[2]);
98 #endif
99   for (Standard_Integer i=1;
100        theOS && nbWritten < mySize && i <= myData.Length();
101        i++) {
102     Standard_Integer nbToWrite = Min (mySize - nbWritten, BP_PIECESIZE);
103     theOS.write ((char*)myData(i), nbToWrite);
104     nbWritten += nbToWrite;
105   }
106   myIndex = 1;
107   myOffset = BP_HEADSIZE;
108   mySize = BP_HEADSIZE;
109   myIsError = Standard_False;
110   return theOS;
111 }
112
113 //=======================================================================
114 //function : Read
115 //purpose  : Retrieves <me> from the stream.
116 //           inline Standard_IStream& operator>> (Standard_IStream&,
117 //           BinObjMgt_Persistent&) is also available
118 //=======================================================================
119
120 Standard_IStream& BinObjMgt_Persistent::Read (Standard_IStream& theIS)
121 {
122   myIndex = 1;
123   myOffset = BP_HEADSIZE;
124   mySize = BP_HEADSIZE;
125   myIsError = Standard_False;
126
127   Standard_Integer *aData = (Standard_Integer*) myData(1);
128   aData[0] = 0;         // Type Id
129   aData[1] = 0;         // Object Id
130   aData[2] = 0;         // Data length
131
132   // read TypeId
133   theIS.read ((char*) &aData[0], BP_INTSIZE);
134 #if DO_INVERSE
135   aData[0] = InverseInt (aData[0]);
136 #endif
137   if (theIS && aData[0] > 0) {
138     // read Id and Length
139     theIS.read ((char*)&aData[1], 2 * BP_INTSIZE);
140 #if DO_INVERSE
141     aData[1] = InverseInt (aData[1]);
142     aData[2] = InverseInt (aData[2]);
143 #endif
144     if (theIS && aData[1] > 0 && aData[2] > 0) {
145       mySize += aData[2];
146       // read remaining data
147       Standard_Integer nbRead = BP_HEADSIZE;
148       for (Standard_Integer i=1;
149            theIS && nbRead < mySize;
150            i++) {
151         if (i > myData.Length()) {
152           // grow myData dynamically
153           Standard_Address aPiece = Standard::Allocate (BP_PIECESIZE);
154           myData.Append (aPiece);
155         }
156         Standard_Integer nbToRead = Min (mySize - nbRead, BP_PIECESIZE);
157         char *ptr = (char*)myData(i);
158         if (i == 1) {
159           // 1st piece: reduce the number of bytes by header size
160           ptr += BP_HEADSIZE;
161           if (nbToRead == BP_PIECESIZE) nbToRead -= BP_HEADSIZE;
162         }
163         theIS.read (ptr, nbToRead);
164         nbRead += nbToRead;
165       }
166     }
167     else
168       aData[2] = 0;
169   }
170   return theIS;
171 }
172
173 //=======================================================================
174 //function : Destroy
175 //purpose  : Frees the allocated memory
176 //=======================================================================
177
178 void BinObjMgt_Persistent::Destroy ()
179 {
180   for (Standard_Integer i=1; i <= myData.Length(); i++) {
181     Standard::Free (myData(i));
182   }
183   myData.Clear();
184   myIndex = myOffset = mySize = 0;
185 }
186
187 //=======================================================================
188 //function : incrementData
189 //purpose  : Allocates theNbPieces more pieces
190 //=======================================================================
191
192 void BinObjMgt_Persistent::incrementData
193   (const Standard_Integer theNbPieces)
194 {
195   for (Standard_Integer i=1; i <= theNbPieces; i++) {
196     Standard_Address aPiece = Standard::Allocate (BP_PIECESIZE);
197     myData.Append (aPiece);
198   }
199 }
200
201 //=======================================================================
202 //function : PutCharacter
203 //purpose  : 
204 //=======================================================================
205
206 BinObjMgt_Persistent& BinObjMgt_Persistent::PutCharacter
207   (const Standard_Character theValue)
208 {
209   alignOffset (1);
210   prepareForPut (1);
211   Standard_Character *aData = (Standard_Character*) myData(myIndex) + myOffset;
212   *aData = theValue;
213   myOffset++;
214   return *this;
215 }
216
217 //=======================================================================
218 //function : PutByte
219 //purpose  : 
220 //=======================================================================
221
222 BinObjMgt_Persistent& BinObjMgt_Persistent::PutByte
223   (const Standard_Byte theValue)
224 {
225   alignOffset (1);
226   prepareForPut (1);
227   Standard_Byte *aData = (Standard_Byte*) myData(myIndex) + myOffset;
228   *aData = theValue;
229   myOffset++;
230   return *this;
231 }
232
233 //=======================================================================
234 //function : PutExtCharacter
235 //purpose  : 
236 //=======================================================================
237
238 BinObjMgt_Persistent& BinObjMgt_Persistent::PutExtCharacter
239   (const Standard_ExtCharacter theValue)
240 {
241   alignOffset (BP_EXTCHARSIZE, Standard_True);
242   prepareForPut (BP_EXTCHARSIZE);
243   Standard_ExtCharacter *aData =
244     (Standard_ExtCharacter*) ((char*)myData(myIndex) + myOffset);
245 #if DO_INVERSE
246   *aData = InverseExtChar (theValue);
247 #else
248   *aData = theValue;
249 #endif
250   myOffset += BP_EXTCHARSIZE;
251   return *this;
252 }
253
254 //=======================================================================
255 //function : PutInteger
256 //purpose  : 
257 //=======================================================================
258
259 BinObjMgt_Persistent& BinObjMgt_Persistent::PutInteger
260   (const Standard_Integer theValue)
261 {
262   alignOffset (BP_INTSIZE, Standard_True);
263   prepareForPut (BP_INTSIZE);
264   Standard_Integer *aData = (Standard_Integer*) ((char*)myData(myIndex) + myOffset);
265 #if DO_INVERSE
266   *aData = InverseInt (theValue);
267 #else
268   *aData = theValue;
269 #endif
270   myOffset += BP_INTSIZE;
271   return *this;
272 }
273
274 //=======================================================================
275 //function : PutReal
276 //purpose  : 
277 //=======================================================================
278
279 BinObjMgt_Persistent& BinObjMgt_Persistent::PutReal
280   (const Standard_Real theValue)
281 {
282   alignOffset (BP_INTSIZE, Standard_True);
283   Standard_Integer nbPieces = prepareForPut (BP_REALSIZE);
284   if (nbPieces > 0) {
285     // the value intersects a piece boundary => go a long way
286 #if DO_INVERSE
287     Standard_Integer aStartIndex = myIndex;
288     Standard_Integer aStartOffset = myOffset;
289 #endif
290     putArray ((void*) &theValue, BP_REALSIZE);
291 #if DO_INVERSE
292     inverseRealData (aStartIndex, aStartOffset, BP_REALSIZE);
293 #endif
294   }
295   else {
296     // the value fits in the current piece => put it quickly
297     Standard_Real *aData = (Standard_Real*) ((char*)myData(myIndex) + myOffset);
298 #if DO_INVERSE
299     *aData = InverseReal (theValue);
300 #else
301     *aData = theValue;
302 #endif
303     myOffset += BP_REALSIZE;
304   }
305   return *this;
306 }
307
308 //=======================================================================
309 //function : PutShortReal
310 //purpose  : 
311 //=======================================================================
312
313 BinObjMgt_Persistent& BinObjMgt_Persistent::PutShortReal
314   (const Standard_ShortReal theValue)
315 {
316   alignOffset (BP_INTSIZE, Standard_True);
317   prepareForPut (BP_SHORTREALSIZE);
318   Standard_ShortReal *aData = (Standard_ShortReal*) ((char*)myData(myIndex) + myOffset);
319 #if DO_INVERSE
320   *aData = InverseShortReal (theValue);
321 #else
322   *aData = theValue;
323 #endif
324   myOffset += BP_SHORTREALSIZE;
325   return *this;
326 }
327
328 //=======================================================================
329 //function : PutCString
330 //purpose  : Offset in output buffer is not aligned
331 //=======================================================================
332
333 BinObjMgt_Persistent& BinObjMgt_Persistent::PutCString
334   (const Standard_CString theValue)
335 {
336   alignOffset (1);
337   Standard_Integer aSize = (Standard_Integer)(strlen (theValue) + 1);
338   prepareForPut (aSize);
339   putArray ((void* )theValue, aSize);
340   return *this;
341 }
342
343 //=======================================================================
344 //function : PutAsciiString
345 //purpose  : Offset in output buffer is word-aligned
346 //=======================================================================
347
348 BinObjMgt_Persistent& BinObjMgt_Persistent::PutAsciiString
349   (const TCollection_AsciiString& theValue)
350 {
351   alignOffset (BP_INTSIZE, Standard_True);
352   Standard_Integer aSize = theValue.Length() + 1;
353   prepareForPut (aSize);
354   putArray ((void*)theValue.ToCString(), aSize);
355   return *this;
356 }
357
358 //=======================================================================
359 //function : PutExtendedString
360 //purpose  : Offset in output buffer is word-aligned
361 //=======================================================================
362
363 BinObjMgt_Persistent& BinObjMgt_Persistent::PutExtendedString
364   (const TCollection_ExtendedString& theValue)
365 {
366   alignOffset (BP_INTSIZE, Standard_True);
367   Standard_Integer aSize = (theValue.Length() + 1) * BP_EXTCHARSIZE;
368   prepareForPut (aSize);
369 #if DO_INVERSE
370   Standard_Integer aStartIndex = myIndex;
371   Standard_Integer aStartOffset = myOffset;
372 #endif
373   putArray ((void* )theValue.ToExtString(), aSize);
374 #if DO_INVERSE
375   inverseExtCharData (aStartIndex, aStartOffset, aSize - BP_EXTCHARSIZE);
376 #endif
377   return *this;
378 }
379
380 //=======================================================================
381 //function : PutLabel
382 //purpose  : 
383 //=======================================================================
384
385 BinObjMgt_Persistent& BinObjMgt_Persistent::PutLabel
386   (const TDF_Label& theValue)
387 {
388   alignOffset (BP_INTSIZE, Standard_True);
389   Standard_Integer aLen = (theValue.IsNull() ? 0 : theValue.Depth()+1);
390   prepareForPut ((aLen + 1) * BP_INTSIZE);
391   Standard_Integer *aData = (Standard_Integer*) ((char*)myData(myIndex) + myOffset);
392   // store nb of tags
393 #if DO_INVERSE
394   *aData++ = InverseInt (aLen);
395 #else
396   *aData++ = aLen;
397 #endif
398   myOffset += BP_INTSIZE;
399   if (!theValue.IsNull()) {
400     TColStd_ListOfInteger aTagList;
401     TDF_Tool::TagList (theValue, aTagList);
402     TColStd_ListIteratorOfListOfInteger itTag(aTagList);
403     for (; itTag.More(); itTag.Next()) {
404       if (myOffset >= BP_PIECESIZE) {
405         myOffset = 0;
406         myIndex++;
407         aData = (Standard_Integer*) ((char*)myData(myIndex) + myOffset);
408       }
409 #if DO_INVERSE
410       *aData++ = InverseInt (itTag.Value());
411 #else
412       *aData++ = itTag.Value();
413 #endif
414       myOffset += BP_INTSIZE;
415     }
416   }
417   return *this;
418 }
419
420 //=======================================================================
421 //function : PutGUID
422 //purpose  : 
423 //=======================================================================
424
425 BinObjMgt_Persistent& BinObjMgt_Persistent::PutGUID
426   (const Standard_GUID& theValue)
427 {
428   alignOffset (BP_INTSIZE, Standard_True);
429   prepareForPut (BP_UUIDSIZE);
430   const Standard_UUID aStandardUUID = theValue.ToUUID();
431   BinObjMgt_UUID anUUID;
432   anUUID.Data1 = (unsigned int)   aStandardUUID.Data1;
433   anUUID.Data2 = (unsigned short) aStandardUUID.Data2;
434   anUUID.Data3 = (unsigned short) aStandardUUID.Data3;
435   anUUID.Data4[0] = aStandardUUID.Data4[0];
436   anUUID.Data4[1] = aStandardUUID.Data4[1];
437   anUUID.Data4[2] = aStandardUUID.Data4[2];
438   anUUID.Data4[3] = aStandardUUID.Data4[3];
439   anUUID.Data4[4] = aStandardUUID.Data4[4];
440   anUUID.Data4[5] = aStandardUUID.Data4[5];
441   anUUID.Data4[6] = aStandardUUID.Data4[6];
442   anUUID.Data4[7] = aStandardUUID.Data4[7];
443 #if DO_INVERSE
444   anUUID.Data1 = (unsigned int)   InverseInt     (anUUID.Data1);
445   anUUID.Data2 = (unsigned short) InverseExtChar (anUUID.Data2);
446   anUUID.Data3 = (unsigned short) InverseExtChar (anUUID.Data3);
447 #endif
448   putArray (&anUUID, BP_UUIDSIZE);
449   return *this;
450 }
451
452 //=======================================================================
453 //function : PutCharArray
454 //purpose  : Put C array of char, theLength is the number of elements
455 //=======================================================================
456
457 BinObjMgt_Persistent& BinObjMgt_Persistent::PutCharArray
458   (const BinObjMgt_PChar  theArray,
459    const Standard_Integer theLength)
460 {
461   alignOffset (1);
462   prepareForPut (theLength);
463   putArray (theArray, theLength);
464   return *this;
465 }
466
467 //=======================================================================
468 //function : PutByteArray
469 //purpose  : Put C array of byte, theLength is the number of elements
470 //=======================================================================
471
472 BinObjMgt_Persistent& BinObjMgt_Persistent::PutByteArray
473   (const BinObjMgt_PByte  theArray,
474    const Standard_Integer theLength)
475 {
476   alignOffset (1);
477   prepareForPut (theLength);
478   putArray (theArray, theLength);
479   return *this;
480 }
481
482 //=======================================================================
483 //function : PutExtCharArray
484 //purpose  : Put C array of ExtCharacter, theLength is the number of elements
485 //=======================================================================
486
487 BinObjMgt_Persistent& BinObjMgt_Persistent::PutExtCharArray
488   (const BinObjMgt_PExtChar theArray,
489    const Standard_Integer   theLength)
490 {
491   alignOffset (BP_EXTCHARSIZE, Standard_True);
492   Standard_Integer aSize = theLength * BP_EXTCHARSIZE;
493   prepareForPut (aSize);
494 #if DO_INVERSE
495   Standard_Integer aStartIndex = myIndex;
496   Standard_Integer aStartOffset = myOffset;
497 #endif
498   putArray (theArray, aSize);
499 #if DO_INVERSE
500   inverseExtCharData (aStartIndex, aStartOffset, aSize);
501 #endif
502   return *this;
503 }
504
505 //=======================================================================
506 //function : PutIntArray
507 //purpose  : Put C array of int, theLength is the number of elements
508 //=======================================================================
509
510 BinObjMgt_Persistent& BinObjMgt_Persistent::PutIntArray
511   (const BinObjMgt_PInteger theArray,
512    const Standard_Integer   theLength)
513 {
514   alignOffset (BP_INTSIZE, Standard_True);
515   Standard_Integer aSize = theLength * BP_INTSIZE;
516   prepareForPut (aSize);
517 #if DO_INVERSE
518   Standard_Integer aStartIndex = myIndex;
519   Standard_Integer aStartOffset = myOffset;
520 #endif
521   putArray (theArray, aSize);
522 #if DO_INVERSE
523   inverseIntData (aStartIndex, aStartOffset, aSize);
524 #endif
525   return *this;
526 }
527
528 //=======================================================================
529 //function : PutRealArray
530 //purpose  : Put C array of double, theLength is the number of elements
531 //=======================================================================
532
533 BinObjMgt_Persistent& BinObjMgt_Persistent::PutRealArray
534   (const BinObjMgt_PReal  theArray,
535    const Standard_Integer theLength)
536 {
537   alignOffset (BP_INTSIZE, Standard_True);
538   Standard_Integer aSize = theLength * BP_REALSIZE;
539   prepareForPut (aSize);
540 #if DO_INVERSE
541   Standard_Integer aStartIndex = myIndex;
542   Standard_Integer aStartOffset = myOffset;
543 #endif
544   putArray (theArray, aSize);
545 #if DO_INVERSE
546   inverseRealData (aStartIndex, aStartOffset, aSize);
547 #endif
548   return *this;
549 }
550
551 //=======================================================================
552 //function : PutShortRealArray
553 //purpose  : Put C array of float, theLength is the number of elements
554 //=======================================================================
555
556 BinObjMgt_Persistent& BinObjMgt_Persistent::PutShortRealArray
557   (const BinObjMgt_PShortReal theArray,
558    const Standard_Integer     theLength)
559 {
560   alignOffset (BP_INTSIZE, Standard_True);
561   Standard_Integer aSize = theLength * BP_SHORTREALSIZE;
562   prepareForPut (aSize);
563 #if DO_INVERSE
564   Standard_Integer aStartIndex = myIndex;
565   Standard_Integer aStartOffset = myOffset;
566 #endif
567   putArray (theArray, aSize);
568 #if DO_INVERSE
569   inverseShortRealData (aStartIndex, aStartOffset, aSize);
570 #endif
571   return *this;
572 }
573
574 //=======================================================================
575 //function : GetCharacter
576 //purpose  : 
577 //=======================================================================
578
579 const BinObjMgt_Persistent& BinObjMgt_Persistent::GetCharacter
580   (Standard_Character& theValue) const
581 {
582   alignOffset (1);
583   if (noMoreData (1)) return *this;
584   Standard_Character *aData = (Standard_Character*) myData(myIndex) + myOffset;
585   theValue = *aData;
586   ((BinObjMgt_Persistent*)this)->myOffset++;
587   return *this;
588 }
589
590 //=======================================================================
591 //function : GetByte
592 //purpose  : 
593 //=======================================================================
594
595 const BinObjMgt_Persistent& BinObjMgt_Persistent::GetByte
596   (Standard_Byte& theValue) const
597 {
598   alignOffset (1);
599   if (noMoreData (1)) return *this;
600   Standard_Byte *aData = (Standard_Byte*) myData(myIndex) + myOffset;
601   theValue = *aData;
602   ((BinObjMgt_Persistent*)this)->myOffset++;
603   return *this;
604 }
605
606 //=======================================================================
607 //function : GetExtCharacter
608 //purpose  : 
609 //=======================================================================
610
611 const BinObjMgt_Persistent& BinObjMgt_Persistent::GetExtCharacter
612   (Standard_ExtCharacter& theValue) const
613 {
614   alignOffset (BP_EXTCHARSIZE);
615   if (noMoreData (BP_EXTCHARSIZE)) return *this;
616   Standard_ExtCharacter *aData =
617     (Standard_ExtCharacter*) ((char*)myData(myIndex) + myOffset);
618 #if DO_INVERSE
619   theValue = InverseExtChar (*aData);
620 #else
621   theValue = *aData;
622 #endif
623   ((BinObjMgt_Persistent*)this)->myOffset += BP_EXTCHARSIZE;
624   return *this;
625 }
626
627 //=======================================================================
628 //function : GetInteger
629 //purpose  : 
630 //=======================================================================
631
632 const BinObjMgt_Persistent& BinObjMgt_Persistent::GetInteger
633   (Standard_Integer& theValue) const
634 {
635   alignOffset (BP_INTSIZE);
636   if (noMoreData (BP_INTSIZE)) return *this;
637   Standard_Integer *aData = (Standard_Integer*) ((char*)myData(myIndex) + myOffset);
638 #if DO_INVERSE
639   theValue = InverseInt (*aData);
640 #else
641   theValue = *aData;
642 #endif
643   ((BinObjMgt_Persistent*)this)->myOffset += BP_INTSIZE;
644   return *this;
645 }
646
647 //=======================================================================
648 //function : GetReal
649 //purpose  : 
650 //=======================================================================
651
652 const BinObjMgt_Persistent& BinObjMgt_Persistent::GetReal
653   (Standard_Real& theValue) const
654 {
655   alignOffset (BP_INTSIZE);
656   if (noMoreData (BP_REALSIZE)) return *this;
657   Standard_Integer nbPieces = (myOffset + BP_REALSIZE - 1) / BP_PIECESIZE;
658   if (nbPieces > 0) {
659     // the value intersects a piece boundary => go a long way
660     getArray ((void*) &theValue, BP_REALSIZE);
661   }
662   else {
663     // the value fits in the current piece => get it quickly
664     Standard_Real *aData = (Standard_Real*) ((char*)myData(myIndex) + myOffset);
665     theValue = *aData;
666     ((BinObjMgt_Persistent*)this)->myOffset += BP_REALSIZE;
667   }
668 #if DO_INVERSE
669   theValue = InverseReal (theValue);
670 #endif
671   return *this;
672 }
673
674 //=======================================================================
675 //function : GetShortReal
676 //purpose  : 
677 //=======================================================================
678
679 const BinObjMgt_Persistent& BinObjMgt_Persistent::GetShortReal
680   (Standard_ShortReal& theValue) const
681 {
682   alignOffset (BP_INTSIZE);
683   if (noMoreData (BP_SHORTREALSIZE)) return *this;
684   Standard_ShortReal *aData = (Standard_ShortReal*) ((char*)myData(myIndex) + myOffset);
685 #if DO_INVERSE
686   theValue = InverseShortReal (*aData);
687 #else
688   theValue = *aData;
689 #endif
690   ((BinObjMgt_Persistent*)this)->myOffset += BP_SHORTREALSIZE;
691   return *this;
692 }
693
694 //=======================================================================
695 //function : GetAsciiString
696 //purpose  : 
697 //=======================================================================
698
699 const BinObjMgt_Persistent& BinObjMgt_Persistent::GetAsciiString
700   (TCollection_AsciiString& theValue) const
701 {
702   alignOffset (BP_INTSIZE);
703   Standard_Integer aStartIndex = myIndex;
704   Standard_Integer aStartOffset = myOffset;
705   BinObjMgt_Persistent* me = (BinObjMgt_Persistent*)this;
706   char *aData = (char*) myData(myIndex) + myOffset;
707
708   // count the string length
709   while (!noMoreData (1) && *aData++) {
710     me->myOffset++;
711     if (myOffset >= BP_PIECESIZE) {
712       me->myOffset = 0;
713       aData = (char*) myData(++me->myIndex);
714     }
715   }
716   if (IsError()) {
717     me->myIndex = aStartIndex;
718     me->myOffset = aStartOffset;
719     return *this;
720   }
721   me->myOffset++;  // count the end null char
722
723   if (myIndex == aStartIndex) {
724     // all string is in one piece => simply copy
725     theValue = aData - myOffset + aStartOffset;
726   }
727   else {
728     // work through buffer string
729     Standard_Integer aSize = (myIndex - aStartIndex) * BP_PIECESIZE +
730       myOffset - aStartOffset;
731     Standard_Address aString = Standard::Allocate (aSize);
732     me->myIndex = aStartIndex;
733     me->myOffset = aStartOffset;
734     getArray (aString, aSize);
735     theValue = (char*) aString;
736     Standard::Free (aString);
737   }
738
739   return *this;
740 }
741
742 //=======================================================================
743 //function : GetExtendedString
744 //purpose  : 
745 //=======================================================================
746
747 const BinObjMgt_Persistent& BinObjMgt_Persistent::GetExtendedString
748   (TCollection_ExtendedString& theValue) const
749 {
750   alignOffset (BP_INTSIZE);
751   Standard_Integer aStartIndex = myIndex;
752   Standard_Integer aStartOffset = myOffset;
753   BinObjMgt_Persistent* me = (BinObjMgt_Persistent*)this;
754   Standard_ExtCharacter *aData =
755     (Standard_ExtCharacter*) ((char*)myData(myIndex) + myOffset);
756
757   // count the string length
758   while (!noMoreData (1) && *aData++) {
759     me->myOffset += BP_EXTCHARSIZE;
760     if (myOffset >= BP_PIECESIZE) {
761       me->myOffset = 0;
762       aData = (Standard_ExtCharacter*) myData(++me->myIndex);
763     }
764   }
765   if (IsError()) {
766     me->myIndex = aStartIndex;
767     me->myOffset = aStartOffset;
768     return *this;
769   }
770   me->myOffset += BP_EXTCHARSIZE;  // count the end null char
771
772   if (myIndex == aStartIndex) {
773     // all string is in one piece => simply copy
774     theValue = aData - (myOffset - aStartOffset) / BP_EXTCHARSIZE;
775   }
776   else {
777     // work through buffer string
778     Standard_Integer aSize = (myIndex - aStartIndex) * BP_PIECESIZE +
779       (myOffset - aStartOffset);
780     Standard_Address aString = Standard::Allocate (aSize);
781     me->myIndex = aStartIndex;
782     me->myOffset = aStartOffset;
783     getArray (aString, aSize);
784     theValue = (Standard_ExtCharacter*) aString;
785     Standard::Free (aString);
786   }
787 #if DO_INVERSE
788   Standard_PExtCharacter aString = (Standard_PExtCharacter)theValue.ToExtString();
789   for (Standard_Integer i=0; i < theValue.Length(); i++)
790     aString[i] = InverseExtChar (aString[i]);
791 #endif
792
793   return *this;
794 }
795
796 //=======================================================================
797 //function : GetLabel
798 //purpose  : 
799 //=======================================================================
800
801 const BinObjMgt_Persistent& BinObjMgt_Persistent::GetLabel
802   (const Handle(TDF_Data)& theDS,
803    TDF_Label& theValue) const
804 {
805   theValue.Nullify();
806   alignOffset (BP_INTSIZE);
807   if (noMoreData (BP_INTSIZE)) return *this;
808   BinObjMgt_Persistent* me = (BinObjMgt_Persistent*)this;
809   // retrieve nb of tags
810   Standard_Integer *aData = (Standard_Integer*) ((char*)myData(myIndex) + myOffset);
811   Standard_Integer aLen = *aData++;
812 #if DO_INVERSE
813   aLen = InverseInt (aLen);
814 #endif
815   me->myOffset += BP_INTSIZE;
816   if (noMoreData (aLen * BP_INTSIZE)) return *this;
817
818   if (aLen > 0) {
819     // retrieve tag list
820     TColStd_ListOfInteger aTagList;
821     while (aLen > 0) {
822       if (myOffset >= BP_PIECESIZE) {
823         me->myOffset = 0;
824         me->myIndex++;
825         aData = (Standard_Integer*) ((char*)myData(myIndex) + myOffset);
826       }
827 #if DO_INVERSE
828       aTagList.Append (InverseInt (*aData++));
829 #else
830       aTagList.Append (*aData++);
831 #endif
832       me->myOffset += BP_INTSIZE;
833       aLen--;
834     }
835     // find label by entry
836     TDF_Tool::Label (theDS, aTagList, theValue, Standard_True);
837   }
838   return *this;
839 }
840
841 //=======================================================================
842 //function : GetGUID
843 //purpose  : 
844 //=======================================================================
845
846 const BinObjMgt_Persistent& BinObjMgt_Persistent::GetGUID
847   (Standard_GUID& theValue) const
848 {
849   alignOffset (BP_INTSIZE);
850   if (noMoreData (BP_UUIDSIZE))
851     return *this;
852   BinObjMgt_UUID anUUID;
853   getArray (&anUUID, BP_UUIDSIZE);
854 #if DO_INVERSE
855   anUUID.Data1 = (unsigned int)   InverseInt     (anUUID.Data1);
856   anUUID.Data2 = (unsigned short) InverseExtChar (anUUID.Data2);
857   anUUID.Data3 = (unsigned short) InverseExtChar (anUUID.Data3);
858 #endif
859   theValue = Standard_GUID (anUUID.Data1, anUUID.Data2, anUUID.Data3,
860                             ((anUUID.Data4[0] << 8) | (anUUID.Data4[1])),
861                             anUUID.Data4[2], anUUID.Data4[3], anUUID.Data4[4],
862                             anUUID.Data4[5], anUUID.Data4[6], anUUID.Data4[7]);
863   return *this;
864 }
865
866 //=======================================================================
867 //function : GetCharArray
868 //purpose  : Get C array of char, theLength is the number of elements;
869 //           theArray must point to a 
870 //           space enough to place theLength elements
871 //=======================================================================
872
873 const BinObjMgt_Persistent& BinObjMgt_Persistent::GetCharArray
874   (const BinObjMgt_PChar  theArray,
875    const Standard_Integer theLength) const
876 {
877   alignOffset (1);
878   if (noMoreData (theLength)) return *this;
879   getArray (theArray, theLength);
880   return *this;
881 }
882
883 //=======================================================================
884 //function : GetByteArray
885 //purpose  : Get C array of unsigned chars, theLength is the number of elements;
886 //           theArray must point to a 
887 //           space enough to place theLength elements
888 //=======================================================================
889
890 const BinObjMgt_Persistent& BinObjMgt_Persistent::GetByteArray
891   (const BinObjMgt_PByte  theArray,
892    const Standard_Integer theLength) const
893 {
894   alignOffset (1);
895   if (noMoreData (theLength)) return *this;
896   getArray (theArray, theLength);
897   return *this;
898 }
899
900 //=======================================================================
901 //function : GetExtCharArray
902 //purpose  : Get C array of ExtCharacter, theLength is the number of elements;
903 //           theArray must point to a 
904 //           space enough to place theLength elements
905 //=======================================================================
906
907 const BinObjMgt_Persistent& BinObjMgt_Persistent::GetExtCharArray
908   (const BinObjMgt_PExtChar theArray,
909    const Standard_Integer   theLength) const
910 {
911   alignOffset (BP_EXTCHARSIZE, Standard_True);
912   Standard_Integer aSize = theLength * BP_EXTCHARSIZE;
913   if (noMoreData (aSize)) return *this;
914   getArray (theArray, aSize);
915 #if DO_INVERSE
916   for (Standard_Integer i=0; i < theLength; i++)
917     theArray[i] = InverseExtChar (theArray[i]);
918 #endif
919   return *this;
920 }
921
922 //=======================================================================
923 //function : GetIntArray
924 //purpose  : Get C array of int, theLength is the number of elements;
925 //           theArray must point to a 
926 //           space enough to place theLength elements
927 //=======================================================================
928
929 const BinObjMgt_Persistent& BinObjMgt_Persistent::GetIntArray
930   (const BinObjMgt_PInteger theArray,
931    const Standard_Integer   theLength) const
932 {
933   alignOffset (BP_INTSIZE, Standard_True);
934   Standard_Integer aSize = theLength * BP_INTSIZE;
935   if (noMoreData (aSize)) return *this;
936   getArray (theArray, aSize);
937 #if DO_INVERSE
938   for (Standard_Integer i=0; i < theLength; i++)
939     theArray[i] = InverseInt (theArray[i]);
940 #endif
941   return *this;
942 }
943
944 //=======================================================================
945 //function : GetRealArray
946 //purpose  : Get C array of double, theLength is the number of elements;
947 //           theArray must point to a 
948 //           space enough to place theLength elements
949 //=======================================================================
950
951 const BinObjMgt_Persistent& BinObjMgt_Persistent::GetRealArray
952   (const BinObjMgt_PReal  theArray,
953    const Standard_Integer theLength) const
954 {
955   alignOffset (BP_INTSIZE, Standard_True);
956   Standard_Integer aSize = theLength * BP_REALSIZE;
957   if (noMoreData (aSize)) return *this;
958   getArray (theArray, aSize);
959 #if DO_INVERSE
960   for (Standard_Integer i=0; i < theLength; i++)
961     theArray[i] = InverseReal (theArray[i]);
962 #endif
963   return *this;
964 }
965
966 //=======================================================================
967 //function : GetShortRealArray
968 //purpose  : Get C array of float, theLength is the number of elements;
969 //           theArray must point to a 
970 //           space enough to place theLength elements
971 //=======================================================================
972
973 const BinObjMgt_Persistent& BinObjMgt_Persistent::GetShortRealArray
974   (const BinObjMgt_PShortReal theArray,
975    const Standard_Integer     theLength) const
976 {
977   alignOffset (BP_INTSIZE, Standard_True);
978   Standard_Integer aSize = theLength * BP_SHORTREALSIZE;
979   if (noMoreData (aSize)) return *this;
980   getArray (theArray, aSize);
981 #if DO_INVERSE
982   for (Standard_Integer i=0; i < theLength; i++)
983     theArray[i] = InverseShortReal (theArray[i]);
984 #endif
985   return *this;
986 }
987
988 //=======================================================================
989 //function : putArray
990 //purpose  : Puts theSize bytes from theArray
991 //=======================================================================
992
993 void BinObjMgt_Persistent::putArray
994   (const Standard_Address theArray,
995    const Standard_Integer theSize)
996 {
997   char *aPtr = (char*) theArray;
998   Standard_Integer aLen = theSize;
999   while (aLen > 0) {
1000     if (myOffset >= BP_PIECESIZE) {
1001       myIndex++;
1002       myOffset = 0;
1003     }
1004     Standard_Integer aLenInPiece = Min (aLen, BP_PIECESIZE - myOffset);
1005     char *aData = (char*) myData(myIndex) + myOffset;
1006     memcpy (aData, aPtr, aLenInPiece);
1007     aLen -= aLenInPiece;
1008     aPtr += aLenInPiece;
1009     myOffset += aLenInPiece;
1010   }
1011 }
1012
1013 //=======================================================================
1014 //function : getArray
1015 //purpose  : Gets theLength bytes into theArray
1016 //=======================================================================
1017
1018 void BinObjMgt_Persistent::getArray
1019   (const Standard_Address theArray,
1020    const Standard_Integer theSize) const
1021 {
1022   char *aPtr = (char*) theArray;
1023   Standard_Integer aLen = theSize;
1024   BinObjMgt_Persistent *me = (BinObjMgt_Persistent*) this;
1025   while (aLen > 0) {
1026     if (myOffset >= BP_PIECESIZE) {
1027       me->myIndex++;
1028       me->myOffset = 0;
1029     }
1030     Standard_Integer aLenInPiece = Min (aLen, BP_PIECESIZE - myOffset);
1031     char *aData = (char*) myData(myIndex) + myOffset;
1032     memcpy (aPtr, aData, aLenInPiece);
1033     aLen -= aLenInPiece;
1034     aPtr += aLenInPiece;
1035     me->myOffset += aLenInPiece;
1036   }
1037 }
1038
1039 //=======================================================================
1040 //function : inverseExtCharData
1041 //purpose  : Inverses bytes in the data addressed by the given values
1042 //=======================================================================
1043
1044 void BinObjMgt_Persistent::inverseExtCharData
1045   (const Standard_Integer theIndex,
1046    const Standard_Integer theOffset,
1047    const Standard_Integer theSize)
1048 {
1049   Standard_Integer anIndex = theIndex;
1050   Standard_Integer anOffset = theOffset;
1051   Standard_Integer aLen = theSize;
1052   while (aLen > 0) {
1053     Standard_Integer aLenInPiece = Min (aLen, BP_PIECESIZE - anOffset);
1054     Standard_ExtCharacter *aData = (Standard_ExtCharacter*)
1055       ( (char*) myData(anIndex) + anOffset);
1056     for (Standard_Integer i=0; i < aLenInPiece / BP_EXTCHARSIZE; i++)
1057       aData[i] = FSD_BinaryFile::InverseExtChar (aData[i]);
1058     aLen -= aLenInPiece;
1059     anOffset += aLenInPiece;
1060     if (anOffset >= BP_PIECESIZE) {
1061       anIndex++;
1062       anOffset = 0;
1063     }
1064   }
1065 }
1066
1067 //=======================================================================
1068 //function : inverseIntData
1069 //purpose  : Inverses bytes in the data addressed by the given values
1070 //=======================================================================
1071
1072 void BinObjMgt_Persistent::inverseIntData
1073   (const Standard_Integer theIndex,
1074    const Standard_Integer theOffset,
1075    const Standard_Integer theSize)
1076 {
1077   Standard_Integer anIndex = theIndex;
1078   Standard_Integer anOffset = theOffset;
1079   Standard_Integer aLen = theSize;
1080   while (aLen > 0) {
1081     Standard_Integer aLenInPiece = Min (aLen, BP_PIECESIZE - anOffset);
1082     Standard_Integer *aData = (Standard_Integer*) ((char*)myData(anIndex) + anOffset);
1083     for (Standard_Integer i=0; i < aLenInPiece / BP_INTSIZE; i++)
1084       aData[i] = FSD_BinaryFile::InverseInt (aData[i]);
1085     aLen -= aLenInPiece;
1086     anOffset += aLenInPiece;
1087     if (anOffset >= BP_PIECESIZE) {
1088       anIndex++;
1089       anOffset = 0;
1090     }
1091   }
1092 }
1093
1094 //=======================================================================
1095 //function : inverseRealData
1096 //purpose  : Inverses bytes in the data addressed by the given values
1097 //=======================================================================
1098
1099 void BinObjMgt_Persistent::inverseRealData
1100   (const Standard_Integer theIndex,
1101    const Standard_Integer theOffset,
1102    const Standard_Integer theSize)
1103 {
1104   Standard_Integer anIndex = theIndex;
1105   Standard_Integer anOffset = theOffset;
1106   Standard_Integer aLen = theSize;
1107
1108   union {
1109         Standard_Real*    aRealData;
1110         Standard_Integer* aIntData;
1111       } aWrapUnion;
1112
1113   void *aPrevPtr = 0;
1114   while (aLen > 0) {
1115     Standard_Integer aLenInPiece = Min (aLen, BP_PIECESIZE - anOffset);
1116
1117     aWrapUnion.aRealData = (Standard_Real*) ((char*)myData(anIndex) + anOffset);
1118     
1119     if (aPrevPtr) {
1120       Standard_Integer aTmp;
1121       aTmp = FSD_BinaryFile::InverseInt (*(Standard_Integer*)aPrevPtr);
1122       *(Standard_Integer*)aPrevPtr = FSD_BinaryFile::InverseInt (*aWrapUnion.aIntData);
1123       *aWrapUnion.aIntData = aTmp;
1124       aWrapUnion.aIntData++;
1125       aPrevPtr = 0;
1126     }
1127     for (Standard_Integer i=0; i < aLenInPiece / BP_REALSIZE; i++)
1128       aWrapUnion.aRealData[i] = FSD_BinaryFile::InverseReal(aWrapUnion.aRealData[i]);
1129     if (aLenInPiece % BP_REALSIZE)
1130       aPrevPtr = &aWrapUnion.aRealData[aLenInPiece / BP_REALSIZE];
1131     aLen -= aLenInPiece;
1132     anOffset += aLenInPiece;
1133     if (anOffset >= BP_PIECESIZE) {
1134       anIndex++;
1135       anOffset = 0;
1136     }
1137   }
1138 }
1139
1140 //=======================================================================
1141 //function : inverseShortRealData
1142 //purpose  : Inverses bytes in the data addressed by the given values
1143 //=======================================================================
1144
1145 void BinObjMgt_Persistent::inverseShortRealData
1146   (const Standard_Integer theIndex,
1147    const Standard_Integer theOffset,
1148    const Standard_Integer theSize)
1149 {
1150   Standard_Integer anIndex = theIndex;
1151   Standard_Integer anOffset = theOffset;
1152   Standard_Integer aLen = theSize;
1153   while (aLen > 0) {
1154     Standard_Integer aLenInPiece = Min (aLen, BP_PIECESIZE - anOffset);
1155     Standard_ShortReal *aData =
1156       (Standard_ShortReal *) ((char *)myData(anIndex) + anOffset);
1157     for (Standard_Integer i=0; i < aLenInPiece / BP_INTSIZE; i++)
1158       aData[i] = FSD_BinaryFile::InverseShortReal (aData[i]);
1159     aLen -= aLenInPiece;
1160     anOffset += aLenInPiece;
1161     if (anOffset >= BP_PIECESIZE) {
1162       anIndex++;
1163       anOffset = 0;
1164     }
1165   }
1166 }