0031918: Application Framework - New binary format for fast reading part of OCAF...
[occt.git] / src / BinObjMgt / BinObjMgt_Persistent.lxx
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 #define BP_HEADSIZE        ((Standard_Integer)(3 * sizeof(Standard_Integer)))
17 #define BP_PIECESIZE       102400
18
19 //=======================================================================
20 //function : SetId
21 //purpose  : Sets the Id of the object
22 //=======================================================================
23
24 inline void BinObjMgt_Persistent::SetId (const Standard_Integer theId)
25 {
26   ((Standard_Integer*) myData(1)) [1] = theId;
27 }
28
29 //=======================================================================
30 //function : SetTypeId
31 //purpose  : Sets the Id of the type of the object
32 //=======================================================================
33
34 inline void BinObjMgt_Persistent::SetTypeId (const Standard_Integer theTypeId)
35 {
36   ((Standard_Integer*) myData(1)) [0] = theTypeId;
37   myStreamStart.Nullify();
38 }
39
40 //=======================================================================
41 //function : Id
42 //purpose  : Returns the Id of the object
43 //=======================================================================
44
45 inline Standard_Integer BinObjMgt_Persistent::Id () const
46 {
47   return ((Standard_Integer*) myData(1)) [1];
48 }
49
50 //=======================================================================
51 //function : TypeId
52 //purpose  : Returns the Id of the type of the object
53 //=======================================================================
54
55 inline Standard_Integer BinObjMgt_Persistent::TypeId () const
56 {
57   return ((Standard_Integer*) myData(1)) [0];
58 }
59
60 //=======================================================================
61 //function : Length
62 //purpose  : Returns the length of data
63 //=======================================================================
64
65 inline Standard_Integer BinObjMgt_Persistent::Length () const
66 {
67   return mySize - BP_HEADSIZE;
68 }
69
70 //=======================================================================
71 //function : operator <<
72 //purpose  : 
73 //=======================================================================
74
75 inline Standard_OStream& operator << (Standard_OStream& theOS,
76                                       BinObjMgt_Persistent& theObj)
77 {
78   return theObj.Write (theOS);
79 }
80
81 //=======================================================================
82 //function : operator >>
83 //purpose  : 
84 //=======================================================================
85
86 inline Standard_IStream& operator >> (Standard_IStream& theIS,
87                                       BinObjMgt_Persistent& theObj)
88 {
89   return theObj.Read (theIS);
90 }
91
92 //=======================================================================
93 //function : Position
94 //purpose  : Tells the current position for get/put
95 //=======================================================================
96
97 inline Standard_Integer BinObjMgt_Persistent::Position() const
98 {
99   return (myIndex-1) * BP_PIECESIZE + myOffset;
100 }
101
102 //=======================================================================
103 //function : SetPosition
104 //purpose  : Sets the current position for get/put.
105 //           Resets an error state depending on the validity of thePos.
106 //           Returns the new state (value of IsOK())
107 //=======================================================================
108
109 inline Standard_Boolean BinObjMgt_Persistent::SetPosition
110   (const Standard_Integer thePos) const
111 {
112   ((BinObjMgt_Persistent*)this)->myIndex = thePos / BP_PIECESIZE + 1;
113   ((BinObjMgt_Persistent*)this)->myOffset = thePos % BP_PIECESIZE;
114   ((BinObjMgt_Persistent*)this)->myIsError = thePos > mySize || thePos < BP_HEADSIZE;
115   return !myIsError;
116 }
117
118 //=======================================================================
119 //function : Truncate
120 //purpose  : Truncates the buffer by current position,
121 //           i.e. updates mySize
122 //=======================================================================
123
124 inline void BinObjMgt_Persistent::Truncate()
125 {
126   mySize = Position();
127 }
128
129 //=======================================================================
130 //function : IsError
131 //purpose  : Indicates an error after Get methods or SetPosition
132 //=======================================================================
133
134 inline Standard_Boolean BinObjMgt_Persistent::IsError() const
135 {
136   return myIsError;
137 }
138
139 //=======================================================================
140 //function : IsOK
141 //purpose  : Indicates a good state after Get methods or SetPosition
142 //=======================================================================
143
144 inline Standard_Boolean BinObjMgt_Persistent::IsOK() const
145 {
146   return !myIsError;
147 }
148
149 //=======================================================================
150 //function : alignOffset
151 //purpose  : Aligns myOffset to the given size;
152 //           enters the next piece if the end of the current one is reached;
153 //           toClear==true means to fill unused space by 0
154 //=======================================================================
155
156 inline void BinObjMgt_Persistent::alignOffset
157   (const Standard_Integer theSize,
158    const Standard_Boolean toClear) const
159 {
160   unsigned alignMask = theSize - 1;
161   Standard_Integer anOffset = (myOffset + alignMask) & ~alignMask;
162
163   if (anOffset > myOffset) {
164     if (toClear && anOffset <= BP_PIECESIZE)
165       memset ( ((char*)myData(myIndex)) + myOffset, 0, anOffset - myOffset);
166     ((BinObjMgt_Persistent*)this)->myOffset = anOffset;
167   }
168
169   // ensure there is a room for at least one item in the current piece
170   if (myOffset >= BP_PIECESIZE) {
171     ((BinObjMgt_Persistent*)this)->myIndex++;
172     ((BinObjMgt_Persistent*)this)->myOffset = 0;
173   }
174 }
175
176 //=======================================================================
177 //function : prepareForPut
178 //purpose  : Prepares the room for theSize bytes;
179 //           returns the number of pieces except for the current one
180 //           are to be occupied
181 //=======================================================================
182
183 inline Standard_Integer BinObjMgt_Persistent::prepareForPut
184   (const Standard_Integer theSize)
185 {
186   Standard_Integer nbPieces = (myOffset + theSize - 1) / BP_PIECESIZE;
187   Standard_Integer nbToAdd = myIndex + nbPieces - myData.Length();
188   if (nbToAdd > 0)
189     // create needed pieces
190     incrementData (nbToAdd);
191   Standard_Integer aNewPosition = Position() + theSize;
192   if (aNewPosition > mySize) mySize = aNewPosition;
193   return nbPieces;
194 }
195
196 //=======================================================================
197 //function : noMoreData
198 //purpose  : Checks if there is no more data of the given size starting
199 //           from the current position in myData
200 //=======================================================================
201
202 inline Standard_Boolean BinObjMgt_Persistent::noMoreData
203   (const Standard_Integer theSize) const
204 {
205   ((BinObjMgt_Persistent*)this)->myIsError = Position() + theSize > mySize;
206   return myIsError;
207 }
208
209 //=======================================================================
210 //function : PutBoolean
211 //purpose  : 
212 //=======================================================================
213
214 inline BinObjMgt_Persistent& BinObjMgt_Persistent::PutBoolean
215   (const Standard_Boolean theValue)
216 {
217   return PutInteger ((Standard_Integer) theValue);
218 }
219
220 //=======================================================================
221 //function : GetBoolean
222 //purpose  : 
223 //=======================================================================
224
225 inline const BinObjMgt_Persistent& BinObjMgt_Persistent::GetBoolean
226   (Standard_Boolean& theValue) const
227 {
228 //  Standard_Integer anIntVal = (Standard_Integer) theValue;
229   Standard_Integer anIntVal;
230   GetInteger (anIntVal);
231   theValue = anIntVal != 0;
232   return *this;
233 }