0024624: Lost word in license statement in source files
[occt.git] / src / BOPDS / BOPDS_PassKey.lxx
CommitLineData
4e57c75e 1// Created by: Peter KURNEV
973c2be1 2// Copyright (c) 2010-2014 OPEN CASCADE SAS
4e57c75e 3// Copyright (c) 2007-2010 CEA/DEN, EDF R&D, OPEN CASCADE
4// Copyright (c) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, CEDRAT,
5// EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
6//
973c2be1 7// This file is part of Open CASCADE Technology software library.
4e57c75e 8//
d5f74e42 9// This library is free software; you can redistribute it and/or modify it under
10// the terms of the GNU Lesser General Public License version 2.1 as published
973c2be1 11// by the Free Software Foundation, with special exception defined in the file
12// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
13// distribution for complete text of the license and disclaimer of any warranty.
4e57c75e 14//
973c2be1 15// Alternatively, this file may be used under the terms of Open CASCADE
16// commercial license or contractual agreement.
4e57c75e 17
18static
19 inline Standard_Integer NormalizedId(const Standard_Integer aId,
20 const Standard_Integer aDiv);
21static
22 inline void SortShell(const Standard_Integer n,
23 Standard_Integer* a);
24
25//=======================================================================
26//function :
27//purpose :
28//=======================================================================
29 inline BOPDS_PassKey::BOPDS_PassKey()
30{
31 myAllocator=NCollection_BaseAllocator::CommonBaseAllocator();
32 myPtr=NULL;
33 Clear();
34}
35//=======================================================================
36//function :
37//purpose :
38//=======================================================================
39 inline BOPDS_PassKey::BOPDS_PassKey(const Handle(NCollection_BaseAllocator)& theAllocator)
40{
41 myAllocator=theAllocator;
42 myPtr=NULL;
43 Clear();
44}
45//=======================================================================
46//function :
47//purpose :
48//=======================================================================
49 inline BOPDS_PassKey::BOPDS_PassKey(const BOPDS_PassKey& aOther)
50{
51 Standard_Integer i;
52 //
53 myPtr=NULL;
54 Clear();
55 //
56 myAllocator=aOther.myAllocator;
57 myNbIds=aOther.myNbIds;
58 mySum=aOther.mySum;
59 //
60 if (myNbIds) {
61 myPtr=Allocate(myNbIds);
62 for (i=0; i<myNbIds; ++i) {
63 myPtr[i]=aOther.myPtr[i];
64 }
65 }
66}
67//=======================================================================
68//function :operator =
69//purpose :
70//=======================================================================
71 inline BOPDS_PassKey& BOPDS_PassKey::operator =(const BOPDS_PassKey& aOther)
72{
73 Standard_Integer i;
74 //
75 Clear();
76 //
77 myAllocator=aOther.myAllocator;
78 myNbIds=aOther.myNbIds;
79 mySum=aOther.mySum;
80 //
81 if (myNbIds) {
82 myPtr=Allocate(myNbIds);
83 for (i=0; i<myNbIds; ++i) {
84 myPtr[i]=aOther.myPtr[i];
85 }
86 }
87 //
88 return *this;
89}
90//=======================================================================
91//function :~
92//purpose :
93//=======================================================================
94 inline BOPDS_PassKey::~BOPDS_PassKey()
95{
96 Clear();
97}
98//=======================================================================
99//function :Allocate
100//purpose :
101//=======================================================================
102 inline BOPCol_PInteger BOPDS_PassKey::Allocate(const Standard_Integer theSize)
103{
104 BOPCol_PInteger pPtr;
105 //
106 pPtr=(BOPCol_PInteger)myAllocator->Allocate(theSize*sizeof(Standard_Integer));
107 return pPtr;
108}
109
110//=======================================================================
111//function :Clear
112//purpose :
113//=======================================================================
114 inline void BOPDS_PassKey::Clear()
115{
116 myNbIds=0;
117 mySum=0;
118 if (myPtr) {
547702a1 119 myAllocator->Free(myPtr);
4e57c75e 120 myPtr=NULL;
121 }
122}
123//=======================================================================
124//function :SetIds
125//purpose :
126//=======================================================================
127 inline void BOPDS_PassKey::SetIds(const Standard_Integer aId1)
128{
129 Clear();
130 myNbIds=1;
131 myPtr=Allocate(myNbIds);
132 myPtr[0]=aId1;
133 mySum=NormalizedId(aId1, myNbIds);
134}
135
136//=======================================================================
137//function :SetIds
138//purpose :
139//=======================================================================
140 inline void BOPDS_PassKey::SetIds(const Standard_Integer aId1,
141 const Standard_Integer aId2)
142{
143 Clear();
144 //
145 myNbIds=2;
146 myPtr=Allocate(myNbIds);
147 //
148 if (aId1<aId2) {
149 myPtr[0]=aId1;
150 myPtr[1]=aId2;
151 }
152 else {
153 myPtr[0]=aId2;
154 myPtr[1]=aId1;
155 }
156 //
157 mySum=NormalizedId(aId1, myNbIds);
158 mySum=mySum+NormalizedId(aId2, myNbIds);
159}
160//=======================================================================
161//function :SetIds
162//purpose :
163//=======================================================================
164 inline void BOPDS_PassKey::SetIds(const Standard_Integer aId1,
165 const Standard_Integer aId2,
166 const Standard_Integer aId3)
167{
168 Clear();
169 //
170 myNbIds=3;
171 myPtr=Allocate(myNbIds);
172 //
173 myPtr[0]=aId1;
174 myPtr[1]=aId2;
175 myPtr[2]=aId3;
176 //
177 SortShell(myNbIds, myPtr);
178 //
179 mySum=NormalizedId(aId1, myNbIds);
180 mySum=mySum+NormalizedId(aId2, myNbIds);
181 mySum=mySum+NormalizedId(aId3, myNbIds);
182}
183//=======================================================================
184//function :SetIds
185//purpose :
186//=======================================================================
187 inline void BOPDS_PassKey::SetIds(const Standard_Integer aId1,
188 const Standard_Integer aId2,
189 const Standard_Integer aId3,
190 const Standard_Integer aId4)
191{
192 Clear();
193 //
194 myNbIds=4;
195 myPtr=Allocate(myNbIds);
196 //
197 myPtr[0]=aId1;
198 myPtr[1]=aId2;
199 myPtr[2]=aId3;
200 myPtr[3]=aId4;
201 //
202 SortShell(myNbIds, myPtr);
203 //
204 mySum=NormalizedId(aId1, myNbIds);
205 mySum=mySum+NormalizedId(aId2, myNbIds);
206 mySum=mySum+NormalizedId(aId3, myNbIds);
207 mySum=mySum+NormalizedId(aId4, myNbIds);
208}
209//=======================================================================
210//function :SetIds
211//purpose :
212//=======================================================================
213 inline void BOPDS_PassKey::SetIds(const BOPCol_ListOfInteger& aLI)
214{
215 Standard_Integer i, aId, aSum;
216 BOPCol_ListIteratorOfListOfInteger aIt;
217 //
218 Clear();
219 //
220 myNbIds=aLI.Extent();
221 myPtr=Allocate(myNbIds);
222 //
223 aSum=0;
224 aIt.Initialize(aLI);
225 for (i=0; aIt.More(); aIt.Next(), ++i) {
226 aId=aIt.Value();
227 myPtr[i]=aId;
228 aSum+=NormalizedId(aId, myNbIds);
229 }
230 mySum=aSum;
231 //
232 SortShell(myNbIds, myPtr);
233}
234//=======================================================================
235//function :NbIds
236//purpose :
237//=======================================================================
238 inline Standard_Integer BOPDS_PassKey::NbIds()const
239{
240 return myNbIds;
241}
242//=======================================================================
243//function :Id
244//purpose :
245//=======================================================================
246 inline Standard_Integer BOPDS_PassKey::Id(const Standard_Integer aIndex) const
247{
248 if (aIndex<0 || aIndex>myNbIds-1) {
249 return -1;
250 }
251 return myPtr[aIndex];
252}
253//=======================================================================
254//function :Ids
255//purpose :
256//=======================================================================
257 inline void BOPDS_PassKey::Ids(Standard_Integer& aId1,
258 Standard_Integer& aId2) const
259{
260 aId1=0;
261 aId2=0;
262 if (myNbIds>1) {
263 aId1=myPtr[0];
264 aId2=myPtr[1];
265 }
266}
267//=======================================================================
268//function :IsEqual
269//purpose :
270//=======================================================================
271 inline Standard_Boolean BOPDS_PassKey::IsEqual(const BOPDS_PassKey& aOther) const
272{
273 Standard_Boolean bRet;
274 Standard_Integer i;
275 //
276 bRet=Standard_False;
277 //
278 if (myNbIds!=aOther.myNbIds) {
279 return bRet;
280 }
281 for (i=0; i<myNbIds; ++i) {
282 if (myPtr[i]!=aOther.myPtr[i]) {
283 return bRet;
284 }
285 }
286 return !bRet;
287}
288//=======================================================================
289//function : HashCode
290//purpose :
291//=======================================================================
292 inline Standard_Integer BOPDS_PassKey::HashCode(const Standard_Integer aUpper) const
293{
294 return ::HashCode(mySum, aUpper);
295}
296//=======================================================================
297// function: NormalizedId
298// purpose :
299//=======================================================================
300inline Standard_Integer NormalizedId(const Standard_Integer aId,
301 const Standard_Integer aDiv)
302{
303 Standard_Integer aMax, aTresh, aIdRet;
304 //
305 aIdRet=aId;
306 aMax=::IntegerLast();
307 aTresh=aMax/aDiv;
308 if (aId>aTresh) {
309 aIdRet=aId%aTresh;
310 }
311 return aIdRet;
312}
313//=======================================================================
314// function: SortShell
315// purpose :
316//=======================================================================
317inline void SortShell(const Standard_Integer n,
318 Standard_Integer* a)
319{
320 Standard_Integer nd, i, j, l, d=1;
321 Standard_Integer x;
322 //
323 while(d<=n) {
324 d*=2;
325 }
326 //
327 while (d) {
328 d=(d-1)/2;
329 //
330 nd=n-d;
331 for (i=0; i<nd; ++i) {
332 j=i;
333 m30:;
334 l=j+d;
335 if (a[l] < a[j]) {
336 x=a[j];
337 a[j]=a[l];
338 a[l]=x;
339 j-=d;
340 if (j > -1) {
341 goto m30;
342 }
343 }//if (a[l] < a[j]){
344 }//for (i=0; i<nd; ++i)
345 }//while (1)
346}