0024927: Getting rid of "Persistent" functionality -- Code
[occt.git] / src / DBC / DBC_VArray.gxx
1 // Copyright (c) 1998-1999 Matra Datavision
2 // Copyright (c) 1999-2014 OPEN CASCADE SAS
3 //
4 // This file is part of Open CASCADE Technology software library.
5 //
6 // This library is free software; you can redistribute it and/or modify it under
7 // the terms of the GNU Lesser General Public License version 2.1 as published
8 // by the Free Software Foundation, with special exception defined in the file
9 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
10 // distribution for complete text of the license and disclaimer of any warranty.
11 //
12 // Alternatively, this file may be used under the terms of Open CASCADE
13 // commercial license or contractual agreement.
14
15 #include <Standard_OutOfRange.hxx> 
16 #include <Standard_NegativeValue.hxx>
17 #include <Standard_NullObject.hxx>
18 #include <Standard_NotImplemented.hxx>
19
20 #ifdef OBJS
21 #include <Standard_Persistent.hxx>
22
23 // taille a partir de laquelle la tableau cre son propre container
24 //
25 #define DBC_TAILLE_PLAFOND_CREATION_SEGMENT 10000 
26
27 #include <StandardOBJS_PersistentMacro.hxx>
28 #include <StandardOBJS_PrimitiveTypes.hxx>
29
30 // just use for internal generic identifiaction of Item
31 //
32 static PStandard_ArrayNode DBC_tmpItem;
33
34 #endif
35
36 #ifdef OBJS
37 #include <StandardOBJS_PersistentMacro.hxx>
38 #endif
39
40 DBC_VArray::DBC_VArray() : DBC_BaseArray()
41 {
42 #ifdef CSFDB
43   myData = 0L;
44 #endif  
45 }
46
47 DBC_VArray::DBC_VArray(const Standard_Integer Size) : DBC_BaseArray(Size)
48 {
49   if(Size > 0) {
50 #ifdef CSFDB
51     myData = (DBC_VArrayTNode*)Standard::Allocate(Size * sizeof(DBC_VArrayTNode));
52     DBC_VArrayTNode* ptrtmp = (DBC_VArrayTNode*)myData;
53     for (int i = 0; i < Size; i++) {
54       ptrtmp = new((Standard_Address)ptrtmp) DBC_VArrayTNode();
55       ptrtmp++;
56     }
57
58     //  myData = new DBC_VArrayTNode[Size];
59 #endif
60 #ifdef OBJS
61     Standard_Integer i;
62     myData = new (os_segment::of(this),DBC_VArrayNode::get_os_typespec(),Size) DBC_VArrayNode[Size];
63 #endif
64
65     } else {
66 #ifdef CSFDB
67       myData = 0L;
68 #endif
69 #ifdef OBJS
70       myData = NULL;
71 #endif
72     }
73 }
74
75 DBC_VArray::DBC_VArray(const DBC_VArray& Varray) : DBC_BaseArray(Varray)
76 {
77 #ifdef CSFDB
78   //myData = new DBC_VArrayTNode[mySize];
79
80   myData = (DBC_VArrayTNode*)Standard::Allocate(mySize * sizeof(DBC_VArrayTNode));
81   DBC_VArrayTNode* ptrtmp = (DBC_VArrayTNode*)myData;
82
83   for(Standard_Integer i=0; i<mySize; i++) {
84     ptrtmp = new((Standard_Address)ptrtmp) DBC_VArrayTNode();
85     ((DBC_VArrayTNode*)myData)[i] = ((DBC_VArrayTNode*)Varray.myData)[i];
86     ptrtmp++;
87   }
88 #endif
89 #ifdef OBJS
90   myData = new (os_segment::of(this),DBC_VArrayNode::get_os_typespec(),mySize) DBC_VArrayNode[mySize] ;
91   const DBC_VArrayNode* otherArray = (DBC_VArrayNode*)Varray.myData;
92
93   for(Standard_Integer i=0; i<mySize; i++) {
94     ((DBC_VArrayNode*)myData)[i].SetValue(*((Item*)(otherArray[i].Value())));
95   }
96 #endif
97 }
98
99 // --------------------------------------------------------------------
100 //                                   Resize
101 // --------------------------------------------------------------------
102 void DBC_VArray::Resize (const Standard_Integer NewSize)
103 {
104   Standard_NegativeValue_Raise_if((NewSize < 0),
105                                   "DBC_VArray::Resize with a bad size");
106
107 #ifdef OBJY
108   myData.resize((unsigned int)NewSize) ;
109 #endif
110
111 #ifdef OBJSold
112   Item *newData; 
113   Standard_Integer borne;
114
115   INTERNAL_MODE_OODB_START {
116     os_segment *seg = Storage_CurrentContainer(); 
117     newData = Standard_PersistentAllocation(DBC_tmpItem, NewSize);
118     if ( NewSize < mySize ) {
119       borne = NewSize;
120     }  
121     else {
122       borne = mySize;
123     }
124     for( Standard_Integer i=0; i<borne;i++ ) {
125       newData[i] = myData[i];
126     }
127     if ( myData )
128       delete (PStandard_ArrayNode*) myData;
129     myData = newData;
130     Storage_CurrentContainer() = seg;
131  }
132   INTERNAL_MODE_OODB_END;
133 #endif
134
135 #ifdef OBJS
136   if (NewSize >  mySize) {
137     Standard_Integer i;
138     DBC_VArrayNode* ptr = new (os_segment::of(this),DBC_VArrayNode::get_os_typespec(),NewSize) DBC_VArrayNode[NewSize] ;
139     for(i = 0; i < mySize; i++) {
140       ((DBC_VArrayNode*)ptr)[i].SetValue(*((Item*)(((DBC_VArrayNode*)myData)[i].Value())));
141     }
142
143     if (myData) delete [] myData;  // free old area.
144     myData = ptr;
145   }
146 #endif 
147
148 #ifdef CSFDB
149   if(NewSize >  mySize || !NewSize){
150     Standard_Integer i;
151
152     DBC_VArrayTNode* ptr = 0L;
153     if(NewSize) {
154       ptr = (DBC_VArrayTNode*)Standard::Allocate(NewSize * sizeof(DBC_VArrayTNode));
155     }
156
157     DBC_VArrayTNode* ptrtmp = ptr;
158
159     if (mySize > 0) {
160       if(NewSize) {
161         for(i = 0; i < mySize; i++) {
162           ptrtmp = new((Standard_Address)ptrtmp) DBC_VArrayTNode();
163           ptr[i].SetValue(*((Item *)((DBC_VArrayTNode*)myData)[i].Value()));
164           ptrtmp++;
165         }
166       }
167       
168       ptrtmp = (DBC_VArrayTNode*)myData;
169       for(i = 0; i < mySize; i++) {
170         ptrtmp->DBC_VArrayTNode::~DBC_VArrayTNode();
171         ptrtmp++;
172       }
173       Standard::Free(myData);
174     } else {
175       for(i = 0; i < NewSize; i++) {
176         ptrtmp = new((Standard_Address)ptrtmp) DBC_VArrayTNode();
177         ptrtmp++;
178       }
179     }
180     myData = ptr;
181   } 
182 #endif 
183
184   mySize = NewSize;
185 }
186
187 // --------------------------------------------------------------------
188 //
189 // --------------------------------------------------------------------
190
191 Item& DBC_VArray::Value( const Standard_Integer Index) const 
192 {
193   Standard_OutOfRange_Raise_if((Index < 0 || Index >= mySize),
194                                "Index out of range in VArray::Value");
195 #ifdef OBJY
196   Handle(DBC_VArrayNode) theNode = Handle(DBC_VArrayNode)::DownCast(myData.elem((unsigned int)Index));
197   return *((Item *)theNode->Value());
198 #endif
199
200 #ifdef OBJSold
201   return myData[Index];
202 #endif
203
204 #ifdef OBJS
205   return *((Item*)(((DBC_VArrayNode*)myData)[Index].Value()));
206 #endif
207
208 #ifdef CSFDB
209   return *((Item *)((DBC_VArrayTNode*)myData)[Index].Value());
210 #endif
211 }
212
213 void DBC_VArray::Assign (const DBC_VArray& Right) 
214 {
215 #ifdef OBJY
216   myData.operator=(Right.myData);
217 #endif
218
219 #ifdef OBJS
220   INTERNAL_MODE_OODB_START {
221     for(Standard_Integer i=0; i< mySize; i++){
222       ((DBC_VArrayNode*)myData)[i].SetValue(*((Item*)(((DBC_VArrayNode*)Right.myData)[i].Value())));
223     }
224   }
225   INTERNAL_MODE_OODB_END;
226 #endif
227
228 #ifdef CSFDB
229   Standard_Integer i;
230
231   for(i = 0; i < mySize; i++) {
232     ((DBC_VArrayTNode*)myData)[i].SetValue(*((Item *)((DBC_VArrayTNode*)Right.myData)[i].Value()));
233   }
234 #endif
235 }
236
237
238 // --------------------------------------------------------------------
239 //                                  SetValue
240 // --------------------------------------------------------------------
241 void DBC_VArray::SetValue(const Standard_Integer Index, const Item& Value)
242 {
243   Standard_OutOfRange_Raise_if((Index < 0 || Index >= mySize),
244                                "Index out of range in VArray::SetValue");
245 #ifdef OBJY
246   if (myData.elem((unsigned int)Index).IsNull())
247     {
248       Handle(DBC_VArrayNode) theNode = new DBC_VArrayNode;
249       myData.elem((unsigned int)Index) = theNode;
250       theNode->SetValue(Value);
251     }
252   else
253     {
254       Handle(DBC_VArrayNode) theNode = Handle(DBC_VArrayNode)::DownCast(myData.elem((unsigned int)Index));
255       theNode->SetValue(Value);
256     }
257 #endif 
258
259 #ifdef OBJSold
260   INTERNAL_MODE_OODB_START {
261     myData[Index] = Value;
262   }
263   INTERNAL_MODE_OODB_END;
264 #endif
265
266 #ifdef OBJS
267   ((DBC_VArrayNode*)myData)[Index].SetValue(Value);
268 #endif
269
270 #ifdef CSFDB
271   ((DBC_VArrayTNode*)myData)[Index].SetValue(Value);
272 #endif
273 }
274
275 void DBC_VArray::Destroy()
276 {
277 #ifdef CSFDB
278   if (myData && mySize > 0) {
279     DBC_VArrayTNode* ptrtmp = (DBC_VArrayTNode*)myData;
280     for(Standard_Integer i = 0; i < mySize; i++) {
281       ptrtmp->DBC_VArrayTNode::~DBC_VArrayTNode();
282       ptrtmp++;
283     }
284     Standard::Free(myData);
285     myData = 0L;
286   }
287 #endif  
288 }