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