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