0026912: CLang 3.6.2 compiler warning [-Winconsistent-missing-override]
[occt.git] / src / QANCollection / QANCollection_Stl.cxx
1 // Created on: 2014-04-16
2 // Created by: Denis BOGOLEPOV
3 // Copyright (c) 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 #include <QANCollection.hxx>
17 #include <Draw_Interpretor.hxx>
18
19 #include <NCollection_Array1.hxx>
20 #include <NCollection_List.hxx>
21 #include <NCollection_Sequence.hxx>
22 #include <NCollection_Vector.hxx>
23 #include <NCollection_Map.hxx>
24 #include <NCollection_DataMap.hxx>
25 #include <NCollection_IndexedMap.hxx>
26 #include <NCollection_IndexedDataMap.hxx>
27 #include <Standard_Assert.hxx>
28 #include <OSD_Timer.hxx>
29 #include <OSD_Parallel.hxx>
30 #include <algorithm>
31 #include <list>
32 #include <set>
33 #include <typeinfo>
34 #include <vector>
35
36 //! Size of test data sets.
37 const int THE_TEST_SIZE = 5000;
38
39 namespace {
40   // Auxiliary class to use in std::random_shuffle()
41   struct RandomGenerator {
42     RandomGenerator () { srand(1); }
43     int operator () (int upper) const { return rand() % upper; }
44   };
45 }
46
47 template<class CollectionType, class StlType>
48 struct CollectionFiller
49 {
50   static void Perform (CollectionType** theCollec, Standard_Integer theSize = THE_TEST_SIZE)
51   {
52     *theCollec = new CollectionType();
53     srand(1);
54     for (Standard_Integer anIdx = 0; anIdx < theSize; ++anIdx)
55     {
56       (*theCollec)->Append (rand());
57     }
58   }
59
60   static void Perform (StlType** theVector,
61     CollectionType** theCollec, Standard_Integer theSize = THE_TEST_SIZE)
62   {
63     CollectionFiller::Perform (theCollec, theSize);
64
65     *theVector = new StlType ((*theCollec)->begin(), (*theCollec)->end());
66   }
67 };
68
69 template<class T, typename StlType>
70 struct CollectionFiller<NCollection_Array1<T>, StlType>
71 {
72   static void Perform (NCollection_Array1<T>** theCollec,
73     Standard_Integer theSize = THE_TEST_SIZE)
74   {
75     *theCollec = new NCollection_Array1<T> (0, theSize - 1);
76     srand (1);
77     for (Standard_Integer anIdx = 0; anIdx < theSize; ++anIdx)
78     {
79       (*theCollec)->ChangeValue (anIdx) = rand();
80     }
81   }
82
83   static void Perform (StlType** theVector,
84     NCollection_Array1<T>** theCollec, Standard_Integer theSize = THE_TEST_SIZE)
85   {
86     CollectionFiller<NCollection_Array1<T>, StlType >::Perform (theCollec, theSize);
87
88     *theVector = new StlType ((*theCollec)->begin(), (*theCollec)->end());
89   }
90 };
91
92 template<class CollectionType, class T>
93 struct MapFiller
94 {
95   static void Perform (CollectionType** theCollec, Standard_Integer theSize = THE_TEST_SIZE)
96   {
97     *theCollec = new CollectionType();
98     srand(1);
99     for (Standard_Integer anIdx = 0; anIdx < theSize; ++anIdx)
100     {
101       (*theCollec)->Add (rand());
102     }
103   }
104 };
105
106 template<class T>
107 struct MapFiller<NCollection_DataMap<T, T>, T>
108 {
109   static void Perform (NCollection_DataMap<T, T>** theCollec1,
110     NCollection_DataMap<T, T>** theCollec2 = NULL, Standard_Integer theSize = THE_TEST_SIZE)
111   {
112     *theCollec1 = new NCollection_DataMap<T, T>();
113
114     if (theCollec2 != NULL)
115       *theCollec2 = new NCollection_DataMap<T, T>();
116     srand(1);
117     for (Standard_Integer anIdx = 0; anIdx < theSize; ++anIdx)
118     {
119       const T aVal1 = rand();
120       const T aVal2 = rand();
121
122       (*theCollec1)->Bind (aVal1, aVal2);
123
124       if (theCollec2 != NULL)
125         (*theCollec2)->Bind (aVal1, aVal2);
126     }
127   }
128 };
129
130 template<class T>
131 struct MapFiller<NCollection_IndexedDataMap<T, T>, T>
132 {
133   static void Perform (NCollection_IndexedDataMap<T, T>** theCollec1,
134     NCollection_IndexedDataMap<T, T>** theCollec2 = NULL, Standard_Integer theSize = THE_TEST_SIZE)
135   {
136     *theCollec1 = new NCollection_IndexedDataMap<T, T>();
137
138     if (theCollec2 != NULL)
139       *theCollec2 = new NCollection_IndexedDataMap<T, T>();
140     srand(1);
141     for (Standard_Integer anIdx = 0; anIdx < theSize; ++anIdx)
142     {
143       const T aVal1 = rand();
144       const T aVal2 = rand();
145
146       (*theCollec1)->Add (aVal1, aVal2);
147
148       if (theCollec2 != NULL)
149         (*theCollec2)->Add (aVal1, aVal2);
150     }
151   }
152 };
153
154 //=======================================================================
155 //function : TestIteration
156 //purpose  :
157 //=======================================================================
158 template<class CollectionType, class StlType>
159 Standard_Boolean TestIteration()
160 {
161   StlType* aVector (NULL);
162   CollectionType* aCollec (NULL);
163
164   CollectionFiller<CollectionType, StlType>::Perform (&aVector, &aCollec);
165
166   typename StlType::iterator aVecIter = aVector->begin();
167   typename CollectionType::iterator aColIter = aCollec->begin();
168
169   Standard_Boolean aResult (Standard_True);
170
171   for (; aVecIter != aVector->end(); ++aVecIter, ++aColIter)
172   {
173     if (*aVecIter != *aColIter)
174       aResult = Standard_False;
175   }
176
177   if (aColIter != aCollec->end())
178   {
179     aResult = Standard_False;
180   }
181
182   delete aVector;
183   delete aCollec;
184
185   return aResult;
186 }
187
188 //=======================================================================
189 //function : TestMinMax
190 //purpose  :
191 //=======================================================================
192 template<class CollectionType, class StlType>
193 Standard_Boolean TestMinMax()
194 {
195   StlType* aVector (NULL);
196   CollectionType* aCollec (NULL);
197
198   CollectionFiller<CollectionType, StlType>::Perform (&aVector, &aCollec);
199
200   typename StlType::value_type aValue1 = *std::min_element (aVector->begin(), aVector->end());
201   typename CollectionType::value_type aValue2 = *std::min_element (aCollec->begin(), aCollec->end());
202
203   Standard_Boolean aResult (Standard_True);
204
205   if (aValue1 != aValue2)
206     aResult = Standard_False;
207
208   aValue1 = *std::max_element (aVector->begin(), aVector->end());
209   aValue2 = *std::max_element (aCollec->begin(), aCollec->end());
210
211   if (aValue1 != aValue2)
212     aResult = Standard_False;
213
214   delete aVector;
215   delete aCollec;
216
217   return aResult;
218 }
219
220 //=======================================================================
221 //function : TestReplace
222 //purpose  :
223 //=======================================================================
224 template<class CollectionType, class StlType>
225 Standard_Boolean TestReplace()
226 {
227   StlType* aVector (NULL);
228   CollectionType* aCollec (NULL);
229
230   CollectionFiller<CollectionType, StlType>::Perform (&aVector, &aCollec);
231
232   const typename StlType::value_type aValue = aVector->back();
233
234   std::replace (aVector->begin(), aVector->end(), aValue, static_cast<typename StlType::value_type> (-1));
235   std::replace (aCollec->begin(), aCollec->end(), aValue, static_cast<typename CollectionType::value_type> (-1));
236
237   typename StlType::iterator aVecIter = aVector->begin();
238   typename CollectionType::iterator aColIter = aCollec->begin();
239
240   Standard_Boolean aResult (Standard_True);
241
242   for (; aVecIter != aVector->end(); ++aVecIter, ++aColIter)
243   {
244     if (*aVecIter != *aColIter)
245       aResult = Standard_False;
246   }
247
248   if (aColIter != aCollec->end())
249   {
250     aResult = Standard_False;
251   }
252
253   delete aVector;
254   delete aCollec;
255
256   return aResult;
257 }
258
259 //=======================================================================
260 //function : TestReverse
261 //purpose  :
262 //=======================================================================
263 template<class CollectionType, class StlType>
264 Standard_Boolean TestReverse()
265 {
266   StlType* aVector (NULL);
267   CollectionType* aCollec (NULL);
268
269   CollectionFiller<CollectionType, StlType>::Perform (&aVector, &aCollec);
270
271   std::reverse (aVector->begin(), aVector->end());
272   std::reverse (aCollec->begin(), aCollec->end());
273
274   typename StlType::iterator aVecIter = aVector->begin();
275   typename CollectionType::iterator aColIter = aCollec->begin();
276
277   Standard_Boolean aResult (Standard_True);
278
279   for (; aVecIter != aVector->end(); ++aVecIter, ++aColIter)
280   {
281     if (*aVecIter != *aColIter)
282       aResult = Standard_False;
283   }
284
285   if (aColIter != aCollec->end())
286   {
287     aResult = Standard_False;
288   }
289
290   delete aVector;
291   delete aCollec;
292
293   return aResult;
294 }
295
296 //=======================================================================
297 //function : TestSort
298 //purpose  :
299 //=======================================================================
300 template<class CollectionType, class StlType>
301 Standard_Boolean TestSort()
302 {
303   StlType* aVector (NULL);
304   CollectionType* aCollec (NULL);
305
306   CollectionFiller<CollectionType, StlType>::Perform (&aVector, &aCollec);
307
308   std::sort (aVector->begin(), aVector->end());
309   std::sort (aCollec->begin(), aCollec->end());
310
311   typename StlType::iterator aVecIter = aVector->begin();
312   typename CollectionType::iterator aColIter = aCollec->begin();
313
314   Standard_Boolean aResult (Standard_True);
315
316   for (; aVecIter != aVector->end(); ++aVecIter, ++aColIter)
317   {
318     if (*aVecIter != *aColIter)
319       aResult = Standard_False;
320   }
321
322   if (aColIter != aCollec->end())
323   {
324     aResult = Standard_False;
325   }
326
327   delete aVector;
328   delete aCollec;
329
330   return aResult;
331 }
332
333 template <typename T>
334 struct Invoker
335 {
336   void operator()(T& theValue) const
337   {
338     theValue *= 2;
339   }
340 };
341
342 //=======================================================================
343 //function : TestParallel
344 //purpose  :
345 //=======================================================================
346 template<class CollectionType, class StlType>
347 Standard_Boolean TestParallel()
348 {
349   StlType* aVector (NULL);
350   CollectionType* aCollec (NULL);
351
352   CollectionFiller<CollectionType, StlType>::Perform (&aVector, &aCollec);
353
354   OSD_Parallel::ForEach(aVector->begin(), aVector->end(), Invoker<typename StlType::value_type>());
355   OSD_Parallel::ForEach(aCollec->begin(), aCollec->end(), Invoker<typename CollectionType::value_type>());
356
357   typename StlType::iterator aVecIter = aVector->begin();
358   typename CollectionType::iterator aColIter = aCollec->begin();
359
360   Standard_Boolean aResult (Standard_True);
361
362   for (; aVecIter != aVector->end(); ++aVecIter, ++aColIter)
363   {
364     if (*aVecIter != *aColIter)
365       aResult = Standard_False;
366   }
367
368   if (aColIter != aCollec->end())
369   {
370     aResult = Standard_False;
371   }
372
373   delete aVector;
374   delete aCollec;
375
376   return aResult;
377 }
378
379 //=======================================================================
380 //function : TestDataMapParallel
381 //purpose  :
382 //=======================================================================
383 template<class CollectionType, class T>
384 Standard_Boolean TestDataMapParallel()
385 {
386   CollectionType* aCollec1 (NULL);
387   CollectionType* aCollec2 (NULL);
388
389   MapFiller<CollectionType, T>::Perform (&aCollec1, &aCollec2);
390
391   OSD_Parallel::ForEach(aCollec1->begin(), aCollec1->end(), Invoker<T>());
392
393   // create OCCT-style iterator
394   typename CollectionType::Iterator aOccIter (*aCollec2);
395
396   // create STL-compatible iterator
397   typename CollectionType::const_iterator aStlIter = aCollec1->cbegin();
398
399   Standard_Boolean aResult (Standard_True);
400
401   for (; aStlIter != aCollec1->cend(); ++aStlIter, aOccIter.Next())
402   {
403     if (static_cast<T> (2) * aOccIter.Value() != *aStlIter)
404       aResult = Standard_False;
405   }
406
407   if (aOccIter.More())
408   {
409     aResult = Standard_False;
410   }
411
412   delete aCollec1;
413   delete aCollec2;
414
415   return aResult;
416 }
417
418 //=======================================================================
419 //function : TestMapIteration
420 //purpose  :
421 //=======================================================================
422 template<class CollectionType, class T>
423 Standard_Boolean TestMapIteration()
424 {
425   CollectionType* aCollec (NULL);
426
427   MapFiller<CollectionType, T>::Perform (&aCollec);
428
429   // create OCCT-style iterator
430   typename CollectionType::Iterator aOccIter (*aCollec);
431
432   // create STL-compatible iterator
433   typename CollectionType::const_iterator aStlIter = aCollec->cbegin();
434
435   Standard_Boolean aResult (Standard_True);
436
437   for (; aStlIter != aCollec->cend(); ++aStlIter, aOccIter.Next())
438   {
439     if (aOccIter.Value() != *aStlIter)
440       aResult = Standard_False;
441   }
442
443   if (aOccIter.More())
444   {
445     aResult = Standard_False;
446   }
447
448   delete aCollec;
449
450   return aResult;
451 }
452
453 //=======================================================================
454 //function : TestForwardIterator
455 //purpose  : test basic features of iterator (forward)
456 //=======================================================================
457 template <class CollectionType>
458 void TestForwardIterator ()
459 {
460   CollectionType* aCollec (NULL);
461
462   CollectionFiller<CollectionType, void>::Perform (&aCollec);
463   
464   // test non-const iteration
465   typename CollectionType::iterator it = aCollec->begin(); // copy construction
466   typename CollectionType::iterator it2; // default constructor
467   it2 = it; // assignment
468   it2 = it++; // postfix increment
469   if (it2 == it || ! (it2 != it))
470     std::cout << "Failed " << typeid(it).name() << " equality check" << std::endl;
471   it2 = ++it; // prefix increment
472   if (it2 != it || ! (it2 == it))
473     std::cout << "Failed " << typeid(it).name() << " equality check" << std::endl;
474
475   typename CollectionType::iterator::value_type t = *it;
476   *it2 = t;
477   *(it2.operator-> ()) = t;
478
479   // test const iteration
480   typename CollectionType::const_iterator cit = aCollec->cbegin(); // copy construction
481   typename CollectionType::const_iterator cit2; // default constructor
482   cit2 = cit; // assignment
483   cit2 = cit++; // postfix increment
484   if (cit2 == cit || ! (cit2 != cit))
485     std::cout << "Failed " << typeid(cit).name() << " equality check" << std::endl;
486   cit2 = ++cit; // prefix increment
487   if (cit2 != it || ! (cit2 == cit))
488     std::cout << "Failed " << typeid(cit).name() << " equality check" << std::endl;
489
490   typename CollectionType::const_iterator::value_type ct = *cit;
491   ct = *cit;
492   (void)ct;
493 //  *cit2 = ct;
494 //  *(cit2.operator-> ()) = t;
495
496   delete aCollec;
497 }
498
499 //=======================================================================
500 //function : TestBidirIterator
501 //purpose  : test features of bidirectional iterator
502 //=======================================================================
503 template <class CollectionType>
504 void TestBidirIterator ()
505 {
506   CollectionType* aCollec (NULL);
507
508   CollectionFiller<CollectionType, void>::Perform (&aCollec);
509   
510   // test non-const iteration
511   typename CollectionType::iterator it = aCollec->end(); // copy construction
512   typename CollectionType::iterator it2 = it--; // postfix decrement
513   if (it2 == it || ! (it2 != it))
514     std::cout << "Failed " << typeid(it).name() << " equality check" << std::endl;
515   it2 = --it; // prefix decrement
516   if (it2 != it || ! (it2 == it))
517     std::cout << "Failed " << typeid(it).name() << " equality check" << std::endl;
518
519   delete aCollec;
520 }
521
522 //=======================================================================
523 //function : TestRandomIterator
524 //purpose  : test features of random iterator
525 //=======================================================================
526 template <class CollectionType>
527 void TestRandomIterator ()
528 {
529   CollectionType* aCollec (NULL);
530
531   CollectionFiller<CollectionType, void>::Perform (&aCollec);
532   
533   // test non-const iteration
534   typename CollectionType::iterator it = aCollec->begin(); // copy construction
535   typename CollectionType::iterator it2 = it + 5;
536   if ((it2 - it) != 5)
537     std::cout << "Failed " << typeid(it).name() << " arithmetics" << std::endl;
538   if (it2 < it || it2 <= it || ! (it2 > it) || ! (it2 >= it))
539     std::cout << "Failed " << typeid(it).name() << " comparison" << std::endl;
540   it += 5;
541   if (it2 != it)
542     std::cout << "Failed " << typeid(it).name() << " arithmetics" << std::endl;
543   it2 = it - 5;
544   if ((it2 - it) != -5)
545     std::cout << "Failed " << typeid(it).name() << " arithmetics" << std::endl;
546   if (it2 > it || it2 >= it || ! (it2 < it) || ! (it2 <= it))
547     std::cout << "Failed " << typeid(it).name() << " comparison" << std::endl;
548   it -= 5;
549   if (it2 != it)
550     std::cout << "Failed " << typeid(it).name() << " arithmetics" << std::endl;
551
552   typename CollectionType::value_type t = it[5]; // offset dereference
553   *it = t;
554
555   delete aCollec;
556 }
557
558 //=======================================================================
559 //function : QANListStlIterator
560 //purpose  :
561 //=======================================================================
562 static Standard_Integer QANListStlIterator (Draw_Interpretor&, Standard_Integer, const char**)
563 {
564   // compile-time tests
565   TestForwardIterator <NCollection_List<Standard_Integer> >();
566
567   // run-time tests
568   Standard_Boolean aResult = TestIteration<NCollection_List<int>, std::list<int> >();
569   std::cout << "NCollection_List<int> Iteration:                " <<
570     (aResult ? "SUCCESS" : "FAIL") << std::endl;
571
572   aResult = TestIteration<NCollection_List<double>, std::list<double> >();
573   std::cout << "NCollection_List<double> Iteration:             " <<
574     (aResult ? "SUCCESS" : "FAIL") << std::endl;
575
576   aResult = TestMinMax<NCollection_List<int>, std::list<int> >();
577   std::cout << "NCollection_List<int> Min-Max:                  " <<
578     (aResult ? "SUCCESS" : "FAIL") << std::endl;
579
580   aResult = TestMinMax<NCollection_List<double>, std::list<double> >();
581   std::cout << "NCollection_List<double> Min-Max:               " <<
582     (aResult ? "SUCCESS" : "FAIL") << std::endl;
583
584   aResult = TestReplace<NCollection_List<int>, std::list<int> >();
585   std::cout << "NCollection_List<int> Replace:                  " <<
586     (aResult ? "SUCCESS" : "FAIL") << std::endl;
587
588   aResult = TestReplace<NCollection_List<double>, std::list<double> >();
589   std::cout << "NCollection_List<double> Replace:               " <<
590     (aResult ? "SUCCESS" : "FAIL") << std::endl;
591
592   aResult = TestParallel< NCollection_List<int>, std::list<int> >();
593   std::cout << "NCollection_List<int> Parallel:                 " <<
594     (aResult ? "SUCCESS" : "FAIL") << std::endl;
595
596   aResult = TestParallel<NCollection_List<double>, std::list<double> >();
597   std::cout << "NCollection_List<double> Parallel:              " <<
598     (aResult ? "SUCCESS" : "FAIL") << std::endl;
599
600   return 0;
601 }
602
603 //=======================================================================
604 //function : QANMapStlIterator
605 //purpose  :
606 //=======================================================================
607 static Standard_Integer QANMapStlIterator (Draw_Interpretor&, Standard_Integer, const char**)
608 {
609   // compile-time tests
610 //  TestForwardIterator <NCollection_Map<Standard_Integer> >();
611
612   // run-time tests
613   Standard_Boolean aResult = TestMapIteration<NCollection_Map<Standard_Integer>, Standard_Integer>();
614   std::cout << "NCollection_Map<int> Iteration:                 " <<
615     (aResult ? "SUCCESS" : "FAIL") << std::endl;
616
617   aResult = TestMapIteration<NCollection_Map<Standard_Real>, Standard_Real>();
618   std::cout << "NCollection_Map<double> Iteration:              " <<
619     (aResult ? "SUCCESS" : "FAIL") << std::endl;
620
621   return 0;
622 }
623
624 //=======================================================================
625 //function : QANIndexedMapStlIterator
626 //purpose  :
627 //=======================================================================
628 static Standard_Integer QANIndexedMapStlIterator (Draw_Interpretor&, Standard_Integer, const char**)
629 {
630   // compile-time tests
631 //  TestForwardIterator <NCollection_IndexedMap<Standard_Integer> >();
632 //  TestBidirIterator <NCollection_IndexedMap<Standard_Integer> >();
633
634   // run-time tests
635   Standard_Boolean aResult = TestMapIteration<NCollection_IndexedMap<Standard_Integer>, Standard_Integer>();
636   std::cout << "NCollection_IndexedMap<int> Iteration:          " <<
637     (aResult ? "SUCCESS" : "FAIL") << std::endl;
638
639   aResult = TestMapIteration<NCollection_IndexedMap<Standard_Real>, Standard_Real>();
640   std::cout << "NCollection_IndexedMap<double> Iteration:       " <<
641     (aResult ? "SUCCESS" : "FAIL") << std::endl;
642
643   return 0;
644 }
645
646 //=======================================================================
647 //function : QANDataMapStlIterator
648 //purpose  :
649 //=======================================================================
650 static Standard_Integer QANDataMapStlIterator (Draw_Interpretor&, Standard_Integer, const char**)
651 {
652   // compile-time tests
653 //  TestForwardIterator <NCollection_DataMap<int, int> >();
654 //  TestBidirIterator <NCollection_DataMap<int, int> >();
655
656   // run-time tests
657   Standard_Boolean aResult = TestMapIteration<NCollection_DataMap<Standard_Integer, Standard_Integer>, Standard_Integer>();
658   std::cout << "NCollection_DataMap<int> Iteration:             " <<
659     (aResult ? "SUCCESS" : "FAIL") << std::endl;
660
661   aResult = TestMapIteration<NCollection_DataMap<Standard_Real, Standard_Real>, Standard_Real>();
662   std::cout << "NCollection_DataMap<double> Iteration:          " <<
663     (aResult ? "SUCCESS" : "FAIL") << std::endl;
664
665   aResult = TestDataMapParallel<NCollection_DataMap<Standard_Integer, Standard_Integer>, Standard_Integer>();
666   std::cout << "NCollection_DataMap<int> Parallel:              " <<
667     (aResult ? "SUCCESS" : "FAIL") << std::endl;
668
669   aResult = TestDataMapParallel<NCollection_DataMap<Standard_Real, Standard_Real>, Standard_Real>();
670   std::cout << "NCollection_DataMap<double> Parallel:           " <<
671     (aResult ? "SUCCESS" : "FAIL") << std::endl;
672
673   return 0;
674 }
675
676 //=======================================================================
677 //function : QANIndexedDataMapStlIterator
678 //purpose  :
679 //=======================================================================
680 static Standard_Integer QANIndexedDataMapStlIterator (Draw_Interpretor&, Standard_Integer, const char**)
681 {
682   // compile-time tests
683 //  TestForwardIterator <NCollection_IndexedDataMap<int, int> >();
684 //  TestBidirIterator <NCollection_IndexedDataMap<int, int> >();
685
686   // run-time tests
687   Standard_Boolean aResult = TestMapIteration<NCollection_IndexedDataMap<Standard_Integer, Standard_Integer>, Standard_Integer>();
688   std::cout << "NCollection_IndexedDataMap<int> Iteration:      " <<
689     (aResult ? "SUCCESS" : "FAIL") << std::endl;
690
691   aResult = TestMapIteration<NCollection_IndexedDataMap<Standard_Real, Standard_Real>, Standard_Real>();
692   std::cout << "NCollection_IndexedDataMap<double> Iteration:   " <<
693     (aResult ? "SUCCESS" : "FAIL") << std::endl;
694
695   aResult = TestDataMapParallel<NCollection_IndexedDataMap<Standard_Integer, Standard_Integer>, Standard_Integer>();
696   std::cout << "NCollection_IndexedDataMap<int> Parallel:       " <<
697     (aResult ? "SUCCESS" : "FAIL") << std::endl;
698
699   aResult = TestDataMapParallel<NCollection_IndexedDataMap<Standard_Real, Standard_Real>, Standard_Real>();
700   std::cout << "NCollection_IndexedDataMap<double> Parallel:    " <<
701     (aResult ? "SUCCESS" : "FAIL") << std::endl;
702
703   return 0;
704 }
705
706 //=======================================================================
707 //function : QANSequenceStlIterator
708 //purpose  :
709 //=======================================================================
710 static Standard_Integer QANSequenceStlIterator (Draw_Interpretor&, Standard_Integer, const char**)
711 {
712   // compile-time tests
713   TestForwardIterator <NCollection_Sequence<int> >();
714   TestBidirIterator <NCollection_Sequence<int> >();
715
716   // run-time tests
717   Standard_Boolean aResult = TestIteration<NCollection_Sequence<int>, std::list<int> >();
718   std::cout << "NCollection_Sequence<int> Iteration:            " <<
719     (aResult ? "SUCCESS" : "FAIL") << std::endl;
720
721   aResult = TestIteration<NCollection_Sequence<double>, std::list<double> >();
722   std::cout << "NCollection_Sequence<double> Iteration:         " <<
723     (aResult ? "SUCCESS" : "FAIL") << std::endl;
724
725   aResult = TestMinMax<NCollection_Sequence<int>, std::list<int> >();
726   std::cout << "NCollection_Sequence<int> Min-Max:              " <<
727     (aResult ? "SUCCESS" : "FAIL") << std::endl;
728
729   aResult = TestMinMax<NCollection_Sequence<double>, std::list<double> >();
730   std::cout << "NCollection_Sequence<double> Min-Max:           " <<
731     (aResult ? "SUCCESS" : "FAIL") << std::endl;
732
733   aResult = TestReplace<NCollection_Sequence<int>, std::list<int> >();
734   std::cout << "NCollection_Sequence<int> Replace:              " <<
735     (aResult ? "SUCCESS" : "FAIL") << std::endl;
736
737   aResult = TestReplace<NCollection_Sequence<double>, std::list<double> >();
738   std::cout << "NCollection_Sequence<double> Replace:           " <<
739     (aResult ? "SUCCESS" : "FAIL") << std::endl;
740
741   aResult = TestReverse<NCollection_Sequence<int>, std::list<int> >();
742   std::cout << "NCollection_Sequence<int> Reverse:              " <<
743     (aResult ? "SUCCESS" : "FAIL") << std::endl;
744
745   aResult = TestReverse<NCollection_Sequence<double>, std::list<double> >();
746   std::cout << "NCollection_Sequence<double> Reverse:           " <<
747     (aResult ? "SUCCESS" : "FAIL") << std::endl;
748
749   aResult = TestParallel<NCollection_Sequence<int>, std::list<int> >();
750   std::cout << "NCollection_Sequence<int> Parallel:             " <<
751     (aResult ? "SUCCESS" : "FAIL") << std::endl;
752
753   aResult = TestParallel<NCollection_Sequence<double>, std::list<double> >();
754   std::cout << "NCollection_Sequence<double> Parallel:          " <<
755     (aResult ? "SUCCESS" : "FAIL") << std::endl;
756
757   return 0;
758 }
759
760 //=======================================================================
761 //function : QANVectorStlIterator
762 //purpose  :
763 //=======================================================================
764 static Standard_Integer QANVectorStlIterator (Draw_Interpretor&, Standard_Integer, const char**)
765 {
766   // compile-time tests
767   TestForwardIterator <NCollection_Vector<int> >();
768   TestBidirIterator <NCollection_Vector<int> >();
769   TestRandomIterator <NCollection_Vector<int> >();
770
771   // run-time tests
772   Standard_Boolean aResult = TestIteration<NCollection_Vector<int>, std::vector<int> >();
773   std::cout << "NCollection_Vector<int> Iteration:              " <<
774     (aResult ? "SUCCESS" : "FAIL") << std::endl;
775
776   aResult = TestIteration<NCollection_Vector<double>, std::vector<double> >();
777   std::cout << "NCollection_Vector<double> Iteration:           " <<
778     (aResult ? "SUCCESS" : "FAIL") << std::endl;
779
780   aResult = TestMinMax<NCollection_Vector<int>, std::vector<int> >();
781   std::cout << "NCollection_Vector<int> Min-Max:                " <<
782     (aResult ? "SUCCESS" : "FAIL") << std::endl;
783
784   aResult = TestMinMax<NCollection_Vector<double>, std::vector<double> >();
785   std::cout << "NCollection_Vector<double> Min-Max:             " <<
786     (aResult ? "SUCCESS" : "FAIL") << std::endl;
787
788   aResult = TestReplace<NCollection_Vector<int>, std::vector<int> >();
789   std::cout << "NCollection_Vector<int> Replace:                " <<
790     (aResult ? "SUCCESS" : "FAIL") << std::endl;
791
792   aResult = TestReplace<NCollection_Vector<double>, std::vector<double> >();
793   std::cout << "NCollection_Vector<double> Replace:             " <<
794     (aResult ? "SUCCESS" : "FAIL") << std::endl;
795
796   aResult = TestReverse<NCollection_Vector<int>, std::vector<int> >();
797   std::cout << "NCollection_Vector<int> Reverse:                " <<
798     (aResult ? "SUCCESS" : "FAIL") << std::endl;
799
800   aResult = TestReverse<NCollection_Vector<double>, std::vector<double> >();
801   std::cout << "NCollection_Vector<double> Reverse:             " <<
802     (aResult ? "SUCCESS" : "FAIL") << std::endl;
803
804   aResult = TestSort<NCollection_Vector<int>, std::vector<int> >();
805   std::cout << "NCollection_Vector<int> Sort:                   " <<
806     (aResult ? "SUCCESS" : "FAIL") << std::endl;
807
808   aResult = TestSort<NCollection_Vector<double>, std::vector<double> >();
809   std::cout << "NCollection_Vector<double> Sort:                " <<
810     (aResult ? "SUCCESS" : "FAIL") << std::endl;
811
812   aResult = TestParallel<NCollection_Vector<int>, std::vector<int> >();
813   std::cout << "NCollection_Vector<int> Parallel:               " <<
814     (aResult ? "SUCCESS" : "FAIL") << std::endl;
815
816   aResult = TestParallel<NCollection_Vector<double>, std::vector<double> >();
817   std::cout << "NCollection_Vector<double> Parallel:            " <<
818     (aResult ? "SUCCESS" : "FAIL") << std::endl;
819
820   return 0;
821 }
822
823 //=======================================================================
824 //function : QANArray1StlIterator
825 //purpose  :
826 //=======================================================================
827 static Standard_Integer QANArray1StlIterator (Draw_Interpretor&, Standard_Integer, const char**)
828 {
829   // compile-time tests
830   TestForwardIterator <NCollection_Vector<int> >();
831   TestBidirIterator <NCollection_Vector<int> >();
832   TestRandomIterator <NCollection_Vector<int> >();
833
834   // run-time tests
835   Standard_Boolean aResult = TestIteration<NCollection_Array1<int>, std::vector<int> >();
836   std::cout << "NCollection_Array1<int> Iteration:              " <<
837     (aResult ? "SUCCESS" : "FAIL") << std::endl;
838
839   aResult = TestIteration<NCollection_Array1<double>, std::vector<double> >();
840   std::cout << "NCollection_Array1<double> Iteration:           " <<
841     (aResult ? "SUCCESS" : "FAIL") << std::endl;
842
843   aResult = TestMinMax<NCollection_Array1<int>, std::vector<int> >();
844   std::cout << "NCollection_Array1<int> Min-Max:                " <<
845     (aResult ? "SUCCESS" : "FAIL") << std::endl;
846
847   aResult = TestMinMax<NCollection_Array1<double>, std::vector<double> >();
848   std::cout << "NCollection_Array1<double> Min-Max:             " <<
849     (aResult ? "SUCCESS" : "FAIL") << std::endl;
850
851   aResult = TestReplace<NCollection_Array1<int>, std::vector<int> >();
852   std::cout << "NCollection_Array1<int> Replace:                " <<
853     (aResult ? "SUCCESS" : "FAIL") << std::endl;
854
855   aResult = TestReplace<NCollection_Array1<double>, std::vector<double> >();
856   std::cout << "NCollection_Array1<double> Replace:             " <<
857     (aResult ? "SUCCESS" : "FAIL") << std::endl;
858
859   aResult = TestReverse<NCollection_Array1<int>, std::vector<int> >();
860   std::cout << "NCollection_Array1<int> Reverse:                " <<
861     (aResult ? "SUCCESS" : "FAIL") << std::endl;
862
863   aResult = TestReverse<NCollection_Array1<double>, std::vector<double> >();
864   std::cout << "NCollection_Array1<double> Reverse:             " <<
865     (aResult ? "SUCCESS" : "FAIL") << std::endl;
866
867   aResult = TestSort<NCollection_Array1<int>, std::vector<int> >();
868   std::cout << "NCollection_Array1<int> Sort:                   " <<
869     (aResult ? "SUCCESS" : "FAIL") << std::endl;
870
871   aResult = TestSort<NCollection_Array1<double>, std::vector<double> >();
872   std::cout << "NCollection_Array1<double> Sort:                " <<
873     (aResult ? "SUCCESS" : "FAIL") << std::endl;
874
875   aResult = TestParallel<NCollection_Array1<int>, std::vector<int> >();
876   std::cout << "NCollection_Array1<int> Parallel:               " <<
877     (aResult ? "SUCCESS" : "FAIL") << std::endl;
878
879   aResult = TestParallel<NCollection_Array1<double>, std::vector<double> >();
880   std::cout << "NCollection_Array1<double> Parallel:            " <<
881     (aResult ? "SUCCESS" : "FAIL") << std::endl;
882
883   return 0;
884 }
885
886 //=======================================================================
887 //function : QANTestStlIterators
888 //purpose  :
889 //=======================================================================
890 static Standard_Integer QANTestStlIterators (
891   Draw_Interpretor& theInterpretor, Standard_Integer, const char**)
892 {
893   QANListStlIterator           (theInterpretor, 0, NULL);
894   QANArray1StlIterator         (theInterpretor, 0, NULL);
895   QANVectorStlIterator         (theInterpretor, 0, NULL);
896   QANSequenceStlIterator       (theInterpretor, 0, NULL);
897   QANMapStlIterator            (theInterpretor, 0, NULL);
898   QANDataMapStlIterator        (theInterpretor, 0, NULL);
899   QANIndexedMapStlIterator     (theInterpretor, 0, NULL);
900   QANIndexedDataMapStlIterator (theInterpretor, 0, NULL);
901
902   return 0;
903 }
904
905 //=======================================================================
906 //function : TestPerformanceRandomIterator
907 //purpose  :
908 //=======================================================================
909 template<class CollectionType, class StlType>
910 void TestPerformanceRandomIterator(Draw_Interpretor& di)
911 {
912   OSD_Timer aTimer;
913
914   StlType* aVector (NULL);
915   CollectionType* aCollec (NULL);
916
917   for (Standard_Integer aSize = 10000; aSize <= 1280000; aSize *= 2)
918   {
919     CollectionFiller<CollectionType, StlType>::Perform (&aVector, &aCollec, aSize);
920
921     aTimer.Reset();
922     aTimer.Start();
923     {
924       RandomGenerator aRandomGen;
925       for (Standard_Integer anIdx = 0; anIdx < 10; ++anIdx)
926       {
927         std::sort           (aVector->begin(), aVector->end());
928         std::random_shuffle (aVector->begin(), aVector->end(), aRandomGen);
929       }
930     }
931     aTimer.Stop();
932
933     Standard_Real aStlTime = aTimer.ElapsedTime();
934
935     aTimer.Reset();
936     aTimer.Start();
937     {
938       RandomGenerator aRandomGen;
939       for (Standard_Integer anIdx = 0; anIdx < 10; ++anIdx)
940       {
941         std::sort           (aCollec->begin(), aCollec->end());
942         std::random_shuffle (aCollec->begin(), aCollec->end(), aRandomGen);
943       }
944     }
945     aTimer.Stop();
946
947     Standard_Real aOccTime = aTimer.ElapsedTime();
948
949     di << aSize << "\t" << aStlTime << "\t" <<
950       aOccTime << "\t" << aOccTime / aStlTime << "\n";
951
952     // check that result is the same
953     if ( ! std::equal (aVector->begin(), aVector->end(), aCollec->begin()) )
954       di << "Error: sequences are not the same at the end!" << "\n";
955
956     delete aVector;
957     delete aCollec;
958   }
959 }
960
961 //=======================================================================
962 //function : TestPerformanceForwardIterator
963 //purpose  :
964 //=======================================================================
965 template<class CollectionType, class StlType>
966 void TestPerformanceForwardIterator(Draw_Interpretor& di)
967 {
968   OSD_Timer aTimer;
969
970   StlType* aVector = 0;
971   CollectionType* aCollec = 0;
972
973   for (Standard_Integer aSize = 10000; aSize <= 1280000; aSize *= 2)
974   {
975     CollectionFiller<CollectionType, StlType>::Perform (&aVector, &aCollec, aSize);
976
977     aTimer.Reset();
978     aTimer.Start();
979     {
980       for (Standard_Integer anIdx = 0; anIdx < 1000; ++anIdx)
981       {
982         std::replace (aVector->begin(), aVector->end(), *aVector->begin(), static_cast<typename StlType::value_type> (anIdx));
983       }
984     }
985     aTimer.Stop();
986
987     Standard_Real aStlTime = aTimer.ElapsedTime();
988
989     aTimer.Reset();
990     aTimer.Start();
991     {
992       for (Standard_Integer anIdx = 0; anIdx < 1000; ++anIdx)
993       {
994         std::replace (aCollec->begin(), aCollec->end(), *aCollec->begin(), static_cast<typename CollectionType::value_type> (anIdx));
995       }
996     }
997     aTimer.Stop();
998
999     Standard_Real aOccTime = aTimer.ElapsedTime();
1000
1001     di << aSize << "\t" << aStlTime << "\t" <<
1002       aOccTime << "\t" << aOccTime / aStlTime << "\n";
1003
1004     // check that result is the same
1005     if ( ! std::equal (aVector->begin(), aVector->end(), aCollec->begin()) )
1006       di << "Error: sequences are not the same at the end!" << "\n";
1007
1008     delete aVector;
1009     delete aCollec;
1010   }
1011 }
1012
1013 //=======================================================================
1014 //function : TestPerformanceBidirIterator
1015 //purpose  :
1016 //=======================================================================
1017 template<class CollectionType, class StlType>
1018 void TestPerformanceBidirIterator(Draw_Interpretor& di)
1019 {
1020   OSD_Timer aTimer;
1021
1022   StlType* aVector = 0;
1023   CollectionType* aCollec = 0;
1024
1025   for (Standard_Integer aSize = 10000; aSize <= 1280000; aSize *= 2)
1026   {
1027     CollectionFiller<CollectionType, StlType>::Perform (&aVector, &aCollec, aSize);
1028
1029     aTimer.Reset();
1030     aTimer.Start();
1031     {
1032       for (Standard_Integer anIdx = 0; anIdx < 1000; ++anIdx)
1033       {
1034         std::reverse (aVector->begin(), aVector->end());
1035       }
1036     }
1037     aTimer.Stop();
1038
1039     Standard_Real aStlTime = aTimer.ElapsedTime();
1040
1041     aTimer.Reset();
1042     aTimer.Start();
1043     {
1044       for (Standard_Integer anIdx = 0; anIdx < 1000; ++anIdx)
1045       {
1046         std::reverse (aCollec->begin(), aCollec->end());
1047       }
1048     }
1049     aTimer.Stop();
1050
1051     Standard_Real aOccTime = aTimer.ElapsedTime();
1052
1053     di << aSize << "\t" << aStlTime << "\t" <<
1054       aOccTime << "\t" << aOccTime / aStlTime << "\n";
1055
1056     // check that result is the same
1057     if ( ! std::equal (aVector->begin(), aVector->end(), aCollec->begin()) )
1058       di << "Error: sequences are not the same at the end!" << "\n";
1059
1060     delete aVector;
1061     delete aCollec;
1062   }
1063 }
1064
1065 //=======================================================================
1066 //function : TestPerformanceMapAccess
1067 //purpose  :
1068 //=======================================================================
1069 template<class CollectionType, class T>
1070 void TestPerformanceMapAccess(Draw_Interpretor& di)
1071 {
1072   OSD_Timer aTimer;
1073
1074   CollectionType* aCollec (NULL);
1075
1076   for (Standard_Integer aSize = 100000; aSize <= 3200000; aSize *= 2)
1077   {
1078     MapFiller<CollectionType, T>::Perform (&aCollec, aSize);
1079
1080     std::set<T>    aSet (aCollec->cbegin(), aCollec->cend());
1081     std::vector<T> aVec (aCollec->cbegin(), aCollec->cend());
1082
1083     Standard_Boolean aResult = Standard_True;
1084
1085     aTimer.Reset();
1086     aTimer.Start();
1087     {
1088       for (Standard_Integer anIdx = 0; anIdx < 10000; ++anIdx)
1089       {
1090         if (aSet.find (aVec[anIdx + 1000]) == aSet.end())
1091           aResult = Standard_False;
1092         if (aSet.find (aVec[anIdx + 2000]) == aSet.end())
1093           aResult = Standard_False;
1094         if (aSet.find (aVec[anIdx + 3000]) == aSet.end())
1095           aResult = Standard_False;
1096         if (aSet.find (aVec[anIdx + 4000]) == aSet.end())
1097           aResult = Standard_False;
1098         if (aSet.find (aVec[anIdx + 5000]) == aSet.end())
1099           aResult = Standard_False;
1100       }
1101     }
1102     aTimer.Stop();
1103
1104     Standard_Real aStlTime = aTimer.ElapsedTime();
1105
1106     aTimer.Reset();
1107     aTimer.Start();
1108     {
1109       for (Standard_Integer anIdx = 0; anIdx < 10000; ++anIdx)
1110       {
1111         if (!aCollec->Contains (aVec[anIdx + 1000]))
1112           aResult = Standard_False;
1113         if (!aCollec->Contains (aVec[anIdx + 2000]))
1114           aResult = Standard_False;
1115         if (!aCollec->Contains (aVec[anIdx + 3000]))
1116           aResult = Standard_False;
1117         if (!aCollec->Contains (aVec[anIdx + 4000]))
1118           aResult = Standard_False;
1119         if (!aCollec->Contains (aVec[anIdx + 5000]))
1120           aResult = Standard_False;
1121       }
1122     }
1123     aTimer.Stop();
1124
1125     Standard_Real aOccTime = aTimer.ElapsedTime();
1126
1127     if (aResult)
1128     {
1129       di << aSize << "\t" << aStlTime << "\t" <<
1130         aOccTime << "\t" << (aStlTime > 1e-16 ? aOccTime / aStlTime : -1) << "\n";
1131     }
1132
1133     delete aCollec;
1134   }
1135 }
1136
1137 //=======================================================================
1138 //function : QANTestNCollectionPerformance
1139 //purpose  :
1140 //=======================================================================
1141 static Standard_Integer QANTestNCollectionPerformance (Draw_Interpretor& di, Standard_Integer, const char**)
1142 {
1143   di << "Testing performance (Size | STL time | OCCT time | STL/OCCT boost)" << "\n";
1144
1145   di << "\n" << "std::vector vs NCollection_Array1 (sort):" << "\n\n";
1146   TestPerformanceRandomIterator<NCollection_Array1<double>, std::vector<double> >(di);
1147
1148   di << "\n" << "std::vector vs NCollection_Vector (sort):" << "\n\n";
1149   TestPerformanceRandomIterator<NCollection_Vector<double>, std::vector<double> >(di);
1150
1151   di << "\n" << "std::vector vs NCollection_Array1 (replace):" << "\n\n";
1152   TestPerformanceForwardIterator<NCollection_Array1<double>, std::vector<double> >(di);
1153
1154   di << "\n" << "std::vector vs NCollection_Vector (replace):" << "\n\n";
1155   TestPerformanceForwardIterator<NCollection_Vector<double>, std::vector<double> >(di);
1156
1157   di << "\n" << "std::list vs NCollection_List (replace):" << "\n\n";
1158   TestPerformanceForwardIterator<NCollection_List<double>, std::list<double> >(di);
1159
1160   di << "\n" << "std::list vs NCollection_Sequence (replace):" << "\n\n";
1161   TestPerformanceForwardIterator<NCollection_Sequence<double>, std::list<double> >(di);
1162
1163   di << "\n" << "std::list vs NCollection_Sequence (reverse):" << "\n\n";
1164   TestPerformanceBidirIterator<NCollection_Sequence<double>, std::list<double> >(di);
1165
1166   di << "\n" << "std::set vs NCollection_Map (search):" << "\n\n";
1167   TestPerformanceMapAccess<NCollection_Map<int>, int>(di);
1168
1169   di << "\n" << "std::set vs NCollection_IndexedMap (search):" << "\n\n";
1170   TestPerformanceMapAccess<NCollection_IndexedMap<int>, int>(di);
1171
1172   return 0;
1173 }
1174
1175 //=======================================================================
1176 //function : QANTestNCollectionIndexedMap
1177 //purpose  :
1178 //=======================================================================
1179 static Standard_Integer QANTestNCollectionIndexedMap (Draw_Interpretor& di, Standard_Integer, const char**)
1180 {
1181   OSD_Timer aTimer;
1182
1183   std::vector<Standard_Integer>            aIndxs;
1184   std::vector<Standard_Integer>            aItems;
1185   NCollection_IndexedMap<Standard_Integer> aIndxMap;
1186
1187   const Standard_Integer aNbItems = 1000000;
1188
1189   srand (1);
1190   for (Standard_Integer anId = 1; anId <= aNbItems; ++anId)
1191   {
1192     const Standard_Integer aVal = anId * 2;
1193
1194     aIndxs.push_back (anId);
1195     aItems.push_back (aVal);
1196
1197     aIndxMap.Add  (aVal);
1198   }
1199
1200   aTimer.Start();
1201   for (Standard_Integer anId = 0; anId < aNbItems; ++anId)
1202   {
1203     if (aIndxMap.FindIndex (aItems[anId]) != aIndxs[anId])
1204     {
1205       std::cout << "failed FindIndex\n";
1206     }
1207
1208     if (aIndxMap.FindKey (aIndxs[anId]) != aItems[anId])
1209     {
1210       std::cout << "failed FindKey\n";
1211     }
1212   }
1213   aTimer.Stop();
1214
1215   const Standard_Real aTime1 = aTimer.ElapsedTime();
1216
1217   aTimer.Reset();
1218   aTimer.Start();
1219   for (Standard_Integer anId = 0; anId < aNbItems / 30; ++anId)
1220   {
1221     const Standard_Integer anId2 = Min (aNbItems - 1,
1222       static_cast<Standard_Integer> (rand() / float (RAND_MAX) * aNbItems));
1223
1224     aIndxMap.Swap (aIndxs[anId], aIndxs[anId2]);
1225
1226     std::swap (aIndxs[anId], aIndxs[anId2]);
1227   }
1228   aTimer.Stop();
1229
1230   const Standard_Real aTime2 = aTimer.ElapsedTime();
1231
1232   aTimer.Reset();
1233   aTimer.Start();
1234   for (Standard_Integer anId = 0; anId < aNbItems; ++anId)
1235   {
1236     if (aIndxMap.FindIndex (aItems[anId]) != aIndxs[anId])
1237     {
1238       std::cout << "failed FindIndex\n";
1239     }
1240
1241     if (aIndxMap.FindKey (aIndxs[anId]) != aItems[anId])
1242     {
1243       std::cout << "failed FindKey\n";
1244     }
1245   }
1246   aTimer.Stop();
1247
1248   const Standard_Real aTime3 = aTimer.ElapsedTime();
1249
1250   aTimer.Reset();
1251   aTimer.Start();
1252   for (Standard_Integer anId = 0; anId < aNbItems; ++anId)
1253   {
1254     aIndxMap.RemoveLast();
1255   }
1256   aTimer.Stop();
1257
1258   const Standard_Real aTime4 = aTimer.ElapsedTime();
1259
1260   di << "Search time 1: " << aTime1 << "\n"
1261      << "Swapping time: " << aTime2 << "\n"
1262      << "Search time 2: " << aTime3 << "\n"
1263      << "Remove   time: " << aTime4 << "\n";
1264
1265   return 0;
1266 }
1267
1268 //=======================================================================
1269 //function : QANTestNCollectionIndexedDataMap
1270 //purpose  :
1271 //=======================================================================
1272 static Standard_Integer QANTestNCollectionIndexedDataMap (Draw_Interpretor& di, Standard_Integer, const char**)
1273 {
1274   OSD_Timer aTimer;
1275
1276   std::vector<Standard_Integer>                                  aIndxs;
1277   std::vector<Standard_Integer>                                  aItems;
1278   NCollection_IndexedDataMap<Standard_Integer, Standard_Integer> aIndxMap;
1279
1280   const Standard_Integer aNbItems = 1000000;
1281
1282   srand (1);
1283   for (Standard_Integer anId = 1; anId <= aNbItems; ++anId)
1284   {
1285     const Standard_Integer aVal = anId * 2;
1286
1287     aIndxs.push_back (anId);
1288     aItems.push_back (aVal);
1289
1290     aIndxMap.Add  (aVal, aVal * 2);
1291   }
1292
1293   aTimer.Start();
1294   for (Standard_Integer anId = 0; anId < aNbItems; ++anId)
1295   {
1296     if (aIndxMap.FindIndex (aItems[anId]) != aIndxs[anId])
1297     {
1298       std::cout << "failed FindIndex\n";
1299     }
1300
1301     if (aIndxMap.FindKey (aIndxs[anId]) != aItems[anId])
1302     {
1303       std::cout << "failed FindKey\n";
1304     }
1305   }
1306   aTimer.Stop();
1307
1308   const Standard_Real aTime1 = aTimer.ElapsedTime();
1309
1310   aTimer.Reset();
1311   aTimer.Start();
1312   for (Standard_Integer anId = 0; anId < aNbItems / 30; ++anId)
1313   {
1314     const Standard_Integer anId2 = Min (aNbItems - 1,
1315       static_cast<Standard_Integer> (rand() / float (RAND_MAX) * aNbItems));
1316
1317     aIndxMap.Swap (aIndxs[anId], aIndxs[anId2]);
1318
1319     std::swap (aIndxs[anId], aIndxs[anId2]);
1320   }
1321   aTimer.Stop();
1322
1323   const Standard_Real aTime2 = aTimer.ElapsedTime();
1324
1325   aTimer.Reset();
1326   aTimer.Start();
1327   for (Standard_Integer anId = 0; anId < aNbItems; ++anId)
1328   {
1329     if (aIndxMap.FindIndex (aItems[anId]) != aIndxs[anId])
1330     {
1331       std::cout << "failed FindIndex\n";
1332     }
1333
1334     if (aIndxMap.FindKey (aIndxs[anId]) != aItems[anId])
1335     {
1336       std::cout << "failed FindKey\n";
1337     }
1338   }
1339   aTimer.Stop();
1340
1341   const Standard_Real aTime3 = aTimer.ElapsedTime();
1342
1343   aTimer.Reset();
1344   aTimer.Start();
1345   for (Standard_Integer anId = 0; anId < aNbItems; ++anId)
1346   {
1347     aIndxMap.RemoveLast();
1348   }
1349   aTimer.Stop();
1350
1351   const Standard_Real aTime4 = aTimer.ElapsedTime();
1352
1353   di << "Search time 1: " << aTime1 << "\n"
1354      << "Swapping time: " << aTime2 << "\n"
1355      << "Search time 2: " << aTime3 << "\n"
1356      << "Remove   time: " << aTime4 << "\n";
1357
1358   return 0;
1359 }
1360
1361 //=======================================================================
1362 //function : CommandsStl
1363 //purpose  :
1364 //=======================================================================
1365 void QANCollection::CommandsStl (Draw_Interpretor& theCommands)
1366 {
1367   const char* aGroup = "QANCollection";
1368
1369   theCommands.Add ("QANArray1StlIterator",
1370                    "QANArray1StlIterator",
1371                    __FILE__,
1372                    QANArray1StlIterator,
1373                    aGroup);
1374
1375   theCommands.Add ("QANListStlIterator",
1376                    "QANListStlIterator",
1377                    __FILE__,
1378                    QANListStlIterator,
1379                    aGroup);
1380
1381   theCommands.Add ("QANSequenceStlIterator",
1382                    "QANSequenceStlIterator",
1383                    __FILE__,
1384                    QANSequenceStlIterator,
1385                    aGroup);
1386
1387   theCommands.Add ("QANVectorStlIterator",
1388                    "QANVectorStlIterator",
1389                    __FILE__,
1390                    QANVectorStlIterator,
1391                    aGroup);
1392
1393   theCommands.Add ("QANMapStlIterator",
1394                    "QANMapStlIterator",
1395                    __FILE__,
1396                    QANMapStlIterator,
1397                    aGroup);
1398
1399   theCommands.Add ("QANDataMapStlIterator",
1400                    "QANDataMapStlIterator",
1401                    __FILE__,
1402                    QANDataMapStlIterator,
1403                    aGroup);
1404
1405   theCommands.Add ("QANIndexedMapStlIterator",
1406                    "QANIndexedMapStlIterator",
1407                    __FILE__,
1408                    QANIndexedMapStlIterator,
1409                    aGroup);
1410
1411   theCommands.Add ("QANIndexedDataMapStlIterator",
1412                    "QANIndexedDataMapStlIterator",
1413                    __FILE__,
1414                    QANIndexedDataMapStlIterator,
1415                    aGroup);
1416
1417   theCommands.Add ("QANTestStlIterators",
1418                    "QANTestStlIterators",
1419                    __FILE__,
1420                    QANTestStlIterators,
1421                    aGroup);
1422
1423   theCommands.Add ("QANTestNCollectionPerformance",
1424                    "QANTestNCollectionPerformance",
1425                    __FILE__,
1426                    QANTestNCollectionPerformance,
1427                    aGroup);
1428
1429   theCommands.Add ("QANTestNCollectionIndexedMap",
1430                    "QANTestNCollectionIndexedMap",
1431                    __FILE__,
1432                    QANTestNCollectionIndexedMap,
1433                    aGroup);
1434
1435   theCommands.Add ("QANTestNCollectionIndexedDataMap",
1436                    "QANTestNCollectionIndexedDataMap",
1437                    __FILE__,
1438                    QANTestNCollectionIndexedDataMap,
1439                    aGroup);
1440
1441   return;
1442 }