mirror of
https://git.dev.opencascade.org/repos/occt.git
synced 2025-04-08 18:40:55 +03:00
0024240: Separation of header files for QANCollection into hxx and cxx
Files in QANCollection tests reorganized to avoid placing code in header files
This commit is contained in:
abv
apn
parent
ddf2fe8eeb
commit
3a01a933af
src/QANCollection
FILESQANCollection.cdlQANCollection.cxxQANCollection2.cxxQANCollection3.cxxQANCollectionTest.cxxQANCollection_Alloc.cxxQANCollection_Common2.hxxQANCollection_Common3.hxxQANCollection_FuncArrays.hxxQANCollection_FuncLists.hxxQANCollection_FuncMaps.hxxQANCollection_FuncTest.hxxQANCollection_Perf.cxxQANCollection_PerfArrays.hxxQANCollection_PerfLists.hxxQANCollection_PerfMaps.hxxQANCollection_PerfSparseArray.hxxQANCollection_PerfTest.hxxQANCollection_Simple.cxxQANCollection_Test.cxx
@ -1,22 +1,10 @@
|
||||
FILES
|
||||
QANCollection.cdl
|
||||
QANCollection.cxx
|
||||
QANCollection1.cxx
|
||||
QANCollection2.cxx
|
||||
QANCollection3.cxx
|
||||
QANCollection4.cxx
|
||||
QANCollection_Simple.cxx
|
||||
QANCollection_Test.cxx
|
||||
QANCollection_Perf.cxx
|
||||
QANCollection_Alloc.cxx
|
||||
QANCollection_Stl.cxx
|
||||
QANCollection_Common.cxx
|
||||
QANCollection_Common.hxx
|
||||
QANCollection_Common2.hxx
|
||||
QANCollection_Common3.hxx
|
||||
QANCollection_FuncArrays.hxx
|
||||
QANCollection_FuncLists.hxx
|
||||
QANCollection_FuncMaps.hxx
|
||||
QANCollection_FuncTest.hxx
|
||||
QANCollection_PerfArrays.hxx
|
||||
QANCollection_PerfLists.hxx
|
||||
QANCollection_PerfMaps.hxx
|
||||
QANCollection_PerfTest.hxx
|
||||
QANCollectionTest.cxx
|
||||
QANCollection_PerfSparseArray.hxx
|
||||
|
||||
@ -37,20 +37,11 @@ is
|
||||
MapRealHasher from TColStd,
|
||||
MapIntegerHasher from TColStd);
|
||||
|
||||
|
||||
--- HashCode (thePnt : Pnt from gp;
|
||||
--- theUpper : Integer from Standard)
|
||||
--- returns Integer from Standard;
|
||||
|
||||
--- IsEqual (thePnt1 : Pnt from gp;
|
||||
--- thePnt2 : Pnt from gp)
|
||||
--- returns Boolean from Standard;
|
||||
|
||||
Commands(DI : in out Interpretor from Draw);
|
||||
Commands1(DI : in out Interpretor from Draw);
|
||||
Commands2(DI : in out Interpretor from Draw);
|
||||
Commands3(DI : in out Interpretor from Draw);
|
||||
Commands4(DI : in out Interpretor from Draw);
|
||||
CommandsSimple(DI : in out Interpretor from Draw);
|
||||
CommandsTest(DI : in out Interpretor from Draw);
|
||||
CommandsPerf(DI : in out Interpretor from Draw);
|
||||
CommandsAlloc(DI : in out Interpretor from Draw);
|
||||
CommandsStl(DI : in out Interpretor from Draw);
|
||||
|
||||
end;
|
||||
|
||||
@ -17,13 +17,12 @@
|
||||
#include <Draw_Interpretor.hxx>
|
||||
|
||||
#include <gp_Pnt.hxx>
|
||||
//#include <QANCollection_Common.hxx>
|
||||
|
||||
void QANCollection::Commands (Draw_Interpretor& theCommands)
|
||||
{
|
||||
QANCollection::Commands1 (theCommands);
|
||||
QANCollection::Commands2 (theCommands);
|
||||
QANCollection::Commands3 (theCommands);
|
||||
QANCollection::Commands4 (theCommands);
|
||||
QANCollection::CommandsSimple (theCommands);
|
||||
QANCollection::CommandsTest (theCommands);
|
||||
QANCollection::CommandsPerf (theCommands);
|
||||
QANCollection::CommandsAlloc (theCommands);
|
||||
QANCollection::CommandsStl (theCommands);
|
||||
}
|
||||
|
||||
@ -1,239 +0,0 @@
|
||||
// Created on: 2004-03-05
|
||||
// Created by: Mikhail KUZMITCHEV
|
||||
// Copyright (c) 2004-2014 OPEN CASCADE SAS
|
||||
//
|
||||
// This file is part of Open CASCADE Technology software library.
|
||||
//
|
||||
// This library is free software; you can redistribute it and/or modify it under
|
||||
// the terms of the GNU Lesser General Public License version 2.1 as published
|
||||
// by the Free Software Foundation, with special exception defined in the file
|
||||
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
|
||||
// distribution for complete text of the license and disclaimer of any warranty.
|
||||
//
|
||||
// Alternatively, this file may be used under the terms of Open CASCADE
|
||||
// commercial license or contractual agreement.
|
||||
|
||||
#include <QANCollection.hxx>
|
||||
|
||||
#include <Draw.hxx>
|
||||
#include <Draw_Interpretor.hxx>
|
||||
|
||||
#include <gp_Pnt.hxx>
|
||||
|
||||
// HashCode and IsEquel must be defined for key types of maps
|
||||
Standard_Integer HashCode(const gp_Pnt thePnt, int theUpper)
|
||||
{
|
||||
return HashCode(thePnt.X(),theUpper);
|
||||
}
|
||||
|
||||
Standard_Boolean IsEqual(const gp_Pnt& theP1, const gp_Pnt& theP2)
|
||||
{
|
||||
return theP1.IsEqual(theP2,gp::Resolution());
|
||||
}
|
||||
|
||||
#define ItemType gp_Pnt
|
||||
#define Key1Type gp_Pnt
|
||||
#define Key2Type Standard_Real
|
||||
|
||||
#include <QANCollection_FuncTest.hxx>
|
||||
|
||||
IMPLEMENT_HARRAY1(QANCollection_HArray1Func)
|
||||
IMPLEMENT_HARRAY2(QANCollection_HArray2Func)
|
||||
IMPLEMENT_HSEQUENCE(QANCollection_HSequenceFunc)
|
||||
|
||||
//=======================================================================
|
||||
//function : CheckArguments1
|
||||
//purpose :
|
||||
//=======================================================================
|
||||
Standard_Integer CheckArguments1(Draw_Interpretor& di, Standard_Integer argc, const char ** argv, Standard_Integer& Lower, Standard_Integer& Upper)
|
||||
{
|
||||
if ( argc != 3) {
|
||||
di << "Usage : " << argv[0] << " Lower Upper" << "\n";
|
||||
return 1;
|
||||
}
|
||||
Lower = Draw::Atoi(argv[1]);
|
||||
Upper = Draw::Atoi(argv[2]);
|
||||
if ( Lower > Upper ) {
|
||||
di << "Lower > Upper" << "\n";
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
//=======================================================================
|
||||
//function : CheckArguments2
|
||||
//purpose :
|
||||
//=======================================================================
|
||||
Standard_Integer CheckArguments2(Draw_Interpretor& di, Standard_Integer argc, const char ** argv, Standard_Integer& LowerRow, Standard_Integer& UpperRow, Standard_Integer& LowerCol, Standard_Integer& UpperCol)
|
||||
{
|
||||
if ( argc != 5) {
|
||||
di << "Usage : " << argv[0] << " LowerRow UpperRow LowerCol UpperCol" << "\n";
|
||||
return 1;
|
||||
}
|
||||
LowerRow = Draw::Atoi(argv[1]);
|
||||
UpperRow = Draw::Atoi(argv[2]);
|
||||
LowerCol = Draw::Atoi(argv[3]);
|
||||
UpperCol = Draw::Atoi(argv[4]);
|
||||
if ( LowerRow > UpperRow ) {
|
||||
di << "LowerRow > UpperRow" << "\n";
|
||||
return 1;
|
||||
}
|
||||
if ( LowerCol > UpperCol ) {
|
||||
di << "LowerCol UpperCol> " << "\n";
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
//=======================================================================
|
||||
//function : QANColTestArray1
|
||||
//purpose :
|
||||
//=======================================================================
|
||||
static Standard_Integer QANColTestArray1(Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
|
||||
{
|
||||
Standard_Integer Lower, Upper;
|
||||
if ( CheckArguments1(di, argc, argv, Lower, Upper) ) {
|
||||
return 1;
|
||||
}
|
||||
QANCollection_Array1Func anArr1(Lower, Upper);
|
||||
TestArray1(anArr1);
|
||||
return 0;
|
||||
}
|
||||
|
||||
//=======================================================================
|
||||
//function : QANColTestArray2
|
||||
//purpose :
|
||||
//=======================================================================
|
||||
static Standard_Integer QANColTestArray2(Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
|
||||
{
|
||||
Standard_Integer LowerRow, UpperRow, LowerCol, UpperCol;
|
||||
if ( CheckArguments2(di, argc, argv, LowerRow, UpperRow, LowerCol, UpperCol) ) {
|
||||
return 1;
|
||||
}
|
||||
QANCollection_Array2Func anArr2(LowerRow, UpperRow, LowerCol, UpperCol);
|
||||
TestArray2(anArr2);
|
||||
return 0;
|
||||
}
|
||||
|
||||
//=======================================================================
|
||||
//function : QANColTestMap
|
||||
//purpose :
|
||||
//=======================================================================
|
||||
static Standard_Integer QANColTestMap(Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
|
||||
{
|
||||
if ( argc != 1) {
|
||||
di << "Usage : " << argv[0] << "\n";
|
||||
return 1;
|
||||
}
|
||||
QANCollection_MapFunc aMap;
|
||||
TestMap(aMap);
|
||||
return 0;
|
||||
}
|
||||
|
||||
//=======================================================================
|
||||
//function : QANColTestDataMap
|
||||
//purpose :
|
||||
//=======================================================================
|
||||
static Standard_Integer QANColTestDataMap(Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
|
||||
{
|
||||
if ( argc != 1) {
|
||||
di << "Usage : " << argv[0] << "\n";
|
||||
return 1;
|
||||
}
|
||||
QANCollection_DataMapFunc aDataMap;
|
||||
TestDataMap(aDataMap);
|
||||
return 0;
|
||||
}
|
||||
|
||||
//=======================================================================
|
||||
//function : QANColTestDoubleMap
|
||||
//purpose :
|
||||
//=======================================================================
|
||||
static Standard_Integer QANColTestDoubleMap(Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
|
||||
{
|
||||
if ( argc != 1) {
|
||||
di << "Usage : " << argv[0] << "\n";
|
||||
return 1;
|
||||
}
|
||||
QANCollection_DoubleMapFunc aDoubleMap;
|
||||
TestDoubleMap(aDoubleMap);
|
||||
return 0;
|
||||
}
|
||||
|
||||
//=======================================================================
|
||||
//function : QANColTestIndexedMap
|
||||
//purpose :
|
||||
//=======================================================================
|
||||
static Standard_Integer QANColTestIndexedMap(Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
|
||||
{
|
||||
if ( argc != 1) {
|
||||
di << "Usage : " << argv[0] << "\n";
|
||||
return 1;
|
||||
}
|
||||
QANCollection_IndexedMapFunc aIndexedMap;
|
||||
TestIndexedMap(aIndexedMap);
|
||||
return 0;
|
||||
}
|
||||
|
||||
//=======================================================================
|
||||
//function : QANColTestIndexedDataMap
|
||||
//purpose :
|
||||
//=======================================================================
|
||||
static Standard_Integer QANColTestIndexedDataMap(Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
|
||||
{
|
||||
if ( argc != 1) {
|
||||
di << "Usage : " << argv[0] << "\n";
|
||||
return 1;
|
||||
}
|
||||
QANCollection_IDMapFunc aIDMap;
|
||||
TestIndexedDataMap(aIDMap);
|
||||
return 0;
|
||||
}
|
||||
|
||||
//=======================================================================
|
||||
//function : QANColTestList
|
||||
//purpose :
|
||||
//=======================================================================
|
||||
static Standard_Integer QANColTestList(Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
|
||||
{
|
||||
if ( argc != 1) {
|
||||
di << "Usage : " << argv[0] << "\n";
|
||||
return 1;
|
||||
}
|
||||
QANCollection_ListFunc aList;
|
||||
TestList(aList);
|
||||
return 0;
|
||||
}
|
||||
|
||||
//=======================================================================
|
||||
//function : QANColTestSequence
|
||||
//purpose :
|
||||
//=======================================================================
|
||||
static Standard_Integer QANColTestSequence(Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
|
||||
{
|
||||
if ( argc != 1) {
|
||||
di << "Usage : " << argv[0] << "\n";
|
||||
return 1;
|
||||
}
|
||||
QANCollection_SequenceFunc aSeq;
|
||||
TestSequence(aSeq);
|
||||
return 0;
|
||||
}
|
||||
|
||||
void QANCollection::Commands2(Draw_Interpretor& theCommands) {
|
||||
const char *group = "QANCollection";
|
||||
|
||||
// from agvCollTest/src/CollectionEXE/FuncTestEXE.cxx
|
||||
theCommands.Add("QANColTestArray1", "QANColTestArray1", __FILE__, QANColTestArray1, group);
|
||||
theCommands.Add("QANColTestArray2", "QANColTestArray2", __FILE__, QANColTestArray2, group);
|
||||
theCommands.Add("QANColTestMap", "QANColTestMap", __FILE__, QANColTestMap, group);
|
||||
theCommands.Add("QANColTestDataMap", "QANColTestDataMap", __FILE__, QANColTestDataMap, group);
|
||||
theCommands.Add("QANColTestDoubleMap", "QANColTestDoubleMap", __FILE__, QANColTestDoubleMap, group);
|
||||
theCommands.Add("QANColTestIndexedMap", "QANColTestIndexedMap", __FILE__, QANColTestIndexedMap, group);
|
||||
theCommands.Add("QANColTestIndexedDataMap", "QANColTestIndexedDataMap", __FILE__, QANColTestIndexedDataMap, group);
|
||||
theCommands.Add("QANColTestList", "QANColTestList", __FILE__, QANColTestList, group);
|
||||
theCommands.Add("QANColTestSequence", "QANColTestSequence", __FILE__, QANColTestSequence, group);
|
||||
|
||||
return;
|
||||
}
|
||||
@ -1,215 +0,0 @@
|
||||
// Created on: 2004-03-05
|
||||
// Created by: Mikhail KUZMITCHEV
|
||||
// Copyright (c) 2004-2014 OPEN CASCADE SAS
|
||||
//
|
||||
// This file is part of Open CASCADE Technology software library.
|
||||
//
|
||||
// This library is free software; you can redistribute it and/or modify it under
|
||||
// the terms of the GNU Lesser General Public License version 2.1 as published
|
||||
// by the Free Software Foundation, with special exception defined in the file
|
||||
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
|
||||
// distribution for complete text of the license and disclaimer of any warranty.
|
||||
//
|
||||
// Alternatively, this file may be used under the terms of Open CASCADE
|
||||
// commercial license or contractual agreement.
|
||||
|
||||
#include <QANCollection.hxx>
|
||||
|
||||
#include <Draw.hxx>
|
||||
#include <Draw_Interpretor.hxx>
|
||||
|
||||
#define ItemType gp_Pnt
|
||||
#define Key1Type Standard_Real
|
||||
#define Key2Type Standard_Integer
|
||||
|
||||
#include <QANCollection_PerfTest.hxx>
|
||||
|
||||
#include <QANCollection_PerfSparseArray.hxx>
|
||||
|
||||
IMPLEMENT_HARRAY1(QANCollection_HArray1Perf)
|
||||
IMPLEMENT_HARRAY2(QANCollection_HArray2Perf)
|
||||
IMPLEMENT_HSEQUENCE(QANCollection_HSequencePerf)
|
||||
|
||||
//=======================================================================
|
||||
//function : CheckArguments
|
||||
//purpose :
|
||||
//=======================================================================
|
||||
Standard_Integer CheckArguments(Draw_Interpretor& di, Standard_Integer argc, const char ** argv, Standard_Integer& Repeat, Standard_Integer& Size)
|
||||
{
|
||||
if ( argc != 3) {
|
||||
di << "Usage : " << argv[0] << " Repeat Size" << "\n";
|
||||
return 1;
|
||||
}
|
||||
Repeat = Draw::Atoi(argv[1]);
|
||||
Size = Draw::Atoi(argv[2]);
|
||||
if ( Repeat < 1 ) {
|
||||
di << "Repeat > 0" << "\n";
|
||||
return 1;
|
||||
}
|
||||
if ( Size < 1 ) {
|
||||
di << "Size > 0" << "\n";
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
//=======================================================================
|
||||
//function : QANColPerfArray1
|
||||
//purpose :
|
||||
//=======================================================================
|
||||
static Standard_Integer QANColPerfArray1(Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
|
||||
{
|
||||
Standard_Integer Repeat, Size;
|
||||
if ( CheckArguments(di, argc, argv, Repeat, Size) ) {
|
||||
return 1;
|
||||
}
|
||||
CompArray1(Repeat,Size);
|
||||
return 0;
|
||||
}
|
||||
|
||||
//=======================================================================
|
||||
//function : QANColPerfArray2
|
||||
//purpose :
|
||||
//=======================================================================
|
||||
static Standard_Integer QANColPerfArray2(Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
|
||||
{
|
||||
Standard_Integer Repeat, Size;
|
||||
if ( CheckArguments(di, argc, argv, Repeat, Size) ) {
|
||||
return 1;
|
||||
}
|
||||
CompArray2(Repeat,Size);
|
||||
return 0;
|
||||
}
|
||||
|
||||
//=======================================================================
|
||||
//function : QANColPerfList
|
||||
//purpose :
|
||||
//=======================================================================
|
||||
static Standard_Integer QANColPerfList(Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
|
||||
{
|
||||
Standard_Integer Repeat, Size;
|
||||
if ( CheckArguments(di, argc, argv, Repeat, Size) ) {
|
||||
return 1;
|
||||
}
|
||||
CompList(Repeat,Size);
|
||||
return 0;
|
||||
}
|
||||
|
||||
//=======================================================================
|
||||
//function : QANColPerfSequence
|
||||
//purpose :
|
||||
//=======================================================================
|
||||
static Standard_Integer QANColPerfSequence(Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
|
||||
{
|
||||
Standard_Integer Repeat, Size;
|
||||
if ( CheckArguments(di, argc, argv, Repeat, Size) ) {
|
||||
return 1;
|
||||
}
|
||||
CompSequence(Repeat,Size);
|
||||
return 0;
|
||||
}
|
||||
|
||||
//=======================================================================
|
||||
//function : QANColPerfMap
|
||||
//purpose :
|
||||
//=======================================================================
|
||||
static Standard_Integer QANColPerfMap(Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
|
||||
{
|
||||
Standard_Integer Repeat, Size;
|
||||
if ( CheckArguments(di, argc, argv, Repeat, Size) ) {
|
||||
return 1;
|
||||
}
|
||||
CompMap(Repeat,Size);
|
||||
return 0;
|
||||
}
|
||||
|
||||
//=======================================================================
|
||||
//function : QANColPerfDataMap
|
||||
//purpose :
|
||||
//=======================================================================
|
||||
static Standard_Integer QANColPerfDataMap(Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
|
||||
{
|
||||
Standard_Integer Repeat, Size;
|
||||
if ( CheckArguments(di, argc, argv, Repeat, Size) ) {
|
||||
return 1;
|
||||
}
|
||||
CompDataMap(Repeat,Size);
|
||||
return 0;
|
||||
}
|
||||
|
||||
//=======================================================================
|
||||
//function : QANColPerfDoubleMap
|
||||
//purpose :
|
||||
//=======================================================================
|
||||
static Standard_Integer QANColPerfDoubleMap(Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
|
||||
{
|
||||
Standard_Integer Repeat, Size;
|
||||
if ( CheckArguments(di, argc, argv, Repeat, Size) ) {
|
||||
return 1;
|
||||
}
|
||||
CompDoubleMap(Repeat,Size);
|
||||
return 0;
|
||||
}
|
||||
|
||||
//=======================================================================
|
||||
//function : QANColPerfIndexedMap
|
||||
//purpose :
|
||||
//=======================================================================
|
||||
static Standard_Integer QANColPerfIndexedMap(Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
|
||||
{
|
||||
Standard_Integer Repeat, Size;
|
||||
if ( CheckArguments(di, argc, argv, Repeat, Size) ) {
|
||||
return 1;
|
||||
}
|
||||
CompIndexedMap(Repeat,Size);
|
||||
return 0;
|
||||
}
|
||||
|
||||
//=======================================================================
|
||||
//function : QANColPerfIndexedDataMap
|
||||
//purpose :
|
||||
//=======================================================================
|
||||
static Standard_Integer QANColPerfIndexedDataMap(Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
|
||||
{
|
||||
Standard_Integer Repeat, Size;
|
||||
if ( CheckArguments(di, argc, argv, Repeat, Size) ) {
|
||||
return 1;
|
||||
}
|
||||
CompIndexedDataMap(Repeat,Size);
|
||||
return 0;
|
||||
}
|
||||
|
||||
//=======================================================================
|
||||
//function : QANColCheckSparseArray
|
||||
//purpose :
|
||||
//=======================================================================
|
||||
static Standard_Integer QANColCheckSparseArray(Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
|
||||
{
|
||||
Standard_Integer Repeat, Size;
|
||||
if ( CheckArguments(di, argc, argv, Repeat, Size) ) {
|
||||
return 1;
|
||||
}
|
||||
CompSparseArray(Repeat,Size);
|
||||
return 0;
|
||||
}
|
||||
|
||||
void QANCollection::Commands3(Draw_Interpretor& theCommands) {
|
||||
const char *group = "QANCollection";
|
||||
|
||||
// from agvCollTest/src/CollectionEXE/PerfTestEXE.cxx
|
||||
theCommands.Add("QANColPerfArray1", "QANColPerfArray1 Repeat Size", __FILE__, QANColPerfArray1, group);
|
||||
theCommands.Add("QANColPerfArray2", "QANColPerfArray2 Repeat Size", __FILE__, QANColPerfArray2, group);
|
||||
theCommands.Add("QANColPerfList", "QANColPerfList Repeat Size", __FILE__, QANColPerfList, group);
|
||||
theCommands.Add("QANColPerfSequence", "QANColPerfSequence Repeat Size", __FILE__, QANColPerfSequence, group);
|
||||
theCommands.Add("QANColPerfMap", "QANColPerfMap Repeat Size", __FILE__, QANColPerfMap, group);
|
||||
theCommands.Add("QANColPerfDataMap", "QANColPerfDataMap Repeat Size", __FILE__, QANColPerfDataMap, group);
|
||||
theCommands.Add("QANColPerfDoubleMap", "QANColPerfDoubleMap Repeat Size", __FILE__, QANColPerfDoubleMap, group);
|
||||
theCommands.Add("QANColPerfIndexedMap", "QANColPerfIndexedMap Repeat Size", __FILE__, QANColPerfIndexedMap, group);
|
||||
theCommands.Add("QANColPerfIndexedDataMap", "QANColPerfIndexedDataMap Repeat Size", __FILE__, QANColPerfIndexedDataMap, group);
|
||||
|
||||
theCommands.Add("QANColCheckSparseArray", "QANColCheckSparseArray Repeat Size", __FILE__, QANColCheckSparseArray, group);
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
@ -1,150 +0,0 @@
|
||||
// Created on: 2002-04-16
|
||||
// Created by: Alexander GRIGORIEV
|
||||
// Copyright (c) 2002-2014 OPEN CASCADE SAS
|
||||
//
|
||||
// This file is part of Open CASCADE Technology software library.
|
||||
//
|
||||
// This library is free software; you can redistribute it and/or modify it under
|
||||
// the terms of the GNU Lesser General Public License version 2.1 as published
|
||||
// by the Free Software Foundation, with special exception defined in the file
|
||||
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
|
||||
// distribution for complete text of the license and disclaimer of any warranty.
|
||||
//
|
||||
// Alternatively, this file may be used under the terms of Open CASCADE
|
||||
// commercial license or contractual agreement.
|
||||
|
||||
#include <TColgp_Array1OfPnt.hxx>
|
||||
#include <TColgp_SequenceOfPnt.hxx>
|
||||
|
||||
#define USE_MACROS
|
||||
#ifdef USE_MACROS
|
||||
#include <NCollection_DefineArray1.hxx>
|
||||
#include <NCollection_DefineSequence.hxx>
|
||||
DEFINE_BASECOLLECTION (MyBaseCollPnt, gp_Pnt)
|
||||
DEFINE_ARRAY1 (MyArray1, MyBaseCollPnt, gp_Pnt)
|
||||
DEFINE_SEQUENCE (MySequence, MyBaseCollPnt, gp_Pnt)
|
||||
#else
|
||||
#include <NCollection_Sequence.hxx>
|
||||
#include <NCollection_Array1.hxx>
|
||||
typedef NCollection_Array1<gp_Pnt> MyArray1;
|
||||
typedef NCollection_Sequence<gp_Pnt> MySequence;
|
||||
typedef NCollection_BaseCollection<gp_Pnt> MyBaseCollPnt;
|
||||
#endif
|
||||
|
||||
#define PERF_ENABLE_METERS
|
||||
#include <OSD_PerfMeter.hxx>
|
||||
|
||||
extern Handle(NCollection_BaseAllocator) getAlloc (const int i);
|
||||
|
||||
const Standard_Integer REPEAT = 100;
|
||||
|
||||
void createArray (TColgp_Array1OfPnt& anArrPnt)
|
||||
{
|
||||
OSD_PerfMeter aPerfMeter("Create array");
|
||||
|
||||
for (Standard_Integer j = 0; j < 2*REPEAT; j++) {
|
||||
PERF_START_METER("Create array")
|
||||
for (Standard_Integer i = anArrPnt.Lower(); i <= anArrPnt.Upper(); i++)
|
||||
anArrPnt(i).SetCoord ((double)i, (double)(i+1), (double)(i+2));
|
||||
PERF_STOP_METER("Create array")
|
||||
}
|
||||
}
|
||||
|
||||
void createArray (MyArray1& anArrPnt)
|
||||
{
|
||||
for (Standard_Integer j = 0; j < 2*REPEAT; j++) {
|
||||
PERF_START_METER("Create array")
|
||||
for (Standard_Integer i = anArrPnt.Lower(); i <= anArrPnt.Upper(); i++)
|
||||
anArrPnt(i).SetCoord ((double)i, (double)(i+1), (double)(i+2));
|
||||
PERF_STOP_METER("Create array")
|
||||
}
|
||||
}
|
||||
|
||||
void assignArray (TColgp_Array1OfPnt& aDest, const TColgp_Array1OfPnt& aSrc)
|
||||
{
|
||||
for (Standard_Integer i = 0; i < 2*REPEAT; i++) {
|
||||
PERF_START_METER("Assign array to array")
|
||||
aDest = aSrc;
|
||||
PERF_STOP_METER("Assign array to array")
|
||||
}
|
||||
}
|
||||
|
||||
void assignCollection (MyBaseCollPnt& aDest,
|
||||
const MyBaseCollPnt& aSrc,
|
||||
const char * MeterName)
|
||||
{
|
||||
for (Standard_Integer i = 0; i < REPEAT; i++) {
|
||||
perf_start_meter (MeterName);
|
||||
// if (getAlloc(1).IsNull() == Standard_False)
|
||||
// if (getAlloc(1)->IsKind(STANDARD_TYPE(NCollection_IncAllocator)))
|
||||
// Handle(NCollection_IncAllocator)::DownCast(getAlloc(1)) -> Clean();
|
||||
aDest.Assign(aSrc);
|
||||
perf_stop_meter (MeterName);
|
||||
}
|
||||
}
|
||||
|
||||
void assignArray (MyArray1& aDest,
|
||||
const MyArray1& aSrc)
|
||||
{
|
||||
for (Standard_Integer i = 0; i < 2*REPEAT; i++) {
|
||||
PERF_START_METER("Assign array to array")
|
||||
aDest = aSrc;
|
||||
PERF_STOP_METER("Assign array to array")
|
||||
}
|
||||
}
|
||||
|
||||
void createSequence (TColgp_SequenceOfPnt& aSeq)
|
||||
{
|
||||
for (Standard_Integer j = 0; j < REPEAT; j++) {
|
||||
PERF_START_METER("Clear sequence")
|
||||
aSeq.Clear();
|
||||
PERF_STOP_METER("Clear sequence")
|
||||
PERF_START_METER("Create sequence")
|
||||
for (Standard_Integer i = 0; i < 100000; i++)
|
||||
aSeq.Append (gp_Pnt((double)i, (double)(i+1), (double)(i+2)));
|
||||
PERF_STOP_METER("Create sequence")
|
||||
}
|
||||
}
|
||||
|
||||
void createSequence (MySequence& aSeq)
|
||||
{
|
||||
for (Standard_Integer j = 0; j < REPEAT; j++) {
|
||||
PERF_START_METER("Clear sequence")
|
||||
aSeq.Clear();
|
||||
// if (getAlloc(0).IsNull() == Standard_False)
|
||||
// if (getAlloc(0)->IsKind(STANDARD_TYPE(NCollection_IncAllocator)))
|
||||
// Handle(NCollection_IncAllocator)::DownCast(getAlloc(0)) -> Clean();
|
||||
PERF_STOP_METER("Clear sequence")
|
||||
PERF_START_METER("Create sequence")
|
||||
for (Standard_Integer i = 0; i < 100000; i++)
|
||||
aSeq.Append (gp_Pnt((double)i, (double)(i+1), (double)(i+2)));
|
||||
PERF_STOP_METER("Create sequence")
|
||||
}
|
||||
}
|
||||
|
||||
void assignSequence (TColgp_SequenceOfPnt& aDest,
|
||||
const TColgp_SequenceOfPnt& aSrc)
|
||||
{
|
||||
for (Standard_Integer i = 0; i < REPEAT; i++) {
|
||||
PERF_START_METER("Assign sequence to sequence")
|
||||
aDest = aSrc;
|
||||
PERF_STOP_METER("Assign sequence to sequence")
|
||||
}
|
||||
}
|
||||
|
||||
void assignSequence (MySequence& aDest, const MySequence& aSrc)
|
||||
{
|
||||
for (Standard_Integer i = 0; i < REPEAT; i++) {
|
||||
PERF_START_METER("Assign sequence to sequence")
|
||||
// if (getAlloc(1).IsNull() == Standard_False)
|
||||
// if (getAlloc(1)->IsKind(STANDARD_TYPE(NCollection_IncAllocator)))
|
||||
// Handle(NCollection_IncAllocator)::DownCast(getAlloc(1)) -> Clean();
|
||||
aDest = aSrc;
|
||||
PERF_STOP_METER("Assign sequence to sequence")
|
||||
}
|
||||
}
|
||||
|
||||
void printAllMeters ()
|
||||
{
|
||||
PERF_PRINT_ALL
|
||||
}
|
||||
@ -120,7 +120,7 @@ static Standard_Integer QANColStdAllocator2(Draw_Interpretor& di, Standard_Integ
|
||||
return 0;
|
||||
}
|
||||
|
||||
void QANCollection::Commands4(Draw_Interpretor& theCommands) {
|
||||
void QANCollection::CommandsAlloc(Draw_Interpretor& theCommands) {
|
||||
const char *group = "QANCollection";
|
||||
|
||||
theCommands.Add("QANColStdAllocator1", "QANColStdAllocator1", __FILE__, QANColStdAllocator1, group);
|
||||
@ -1,187 +0,0 @@
|
||||
// Created on: 2002-05-15
|
||||
// Created by: Alexander KARTOMIN (akm)
|
||||
// Copyright (c) 2002-2014 OPEN CASCADE SAS
|
||||
//
|
||||
// This file is part of Open CASCADE Technology software library.
|
||||
//
|
||||
// This library is free software; you can redistribute it and/or modify it under
|
||||
// the terms of the GNU Lesser General Public License version 2.1 as published
|
||||
// by the Free Software Foundation, with special exception defined in the file
|
||||
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
|
||||
// distribution for complete text of the license and disclaimer of any warranty.
|
||||
//
|
||||
// Alternatively, this file may be used under the terms of Open CASCADE
|
||||
// commercial license or contractual agreement.
|
||||
|
||||
#ifndef QANCollection_Common2_HeaderFile
|
||||
#define QANCollection_Common2_HeaderFile
|
||||
|
||||
#include <stdio.h>
|
||||
#include <gp_Pnt.hxx>
|
||||
|
||||
#include <QANCollection_Common.hxx>
|
||||
|
||||
// ===================== INSTANTIATIONS ===========
|
||||
// ===================== The Types must be defined before this line ===========
|
||||
// These are: TheItemType, TheKey1Type, TheKey2Type
|
||||
// So must be defined ::HashCode and ::IsEqual too
|
||||
|
||||
#if defined(ItemType) && defined(Key1Type) && defined(Key2Type)
|
||||
|
||||
#include <NCollection_DefineBaseCollection.hxx>
|
||||
////////////////////////////////DEFINE_BASECOLLECTION(QANCollection_BaseCol,ItemType)
|
||||
////////////////////////////////DEFINE_BASECOLLECTION(QANCollection_Key1BaseCol,Key1Type)
|
||||
////////////////////////////////DEFINE_BASECOLLECTION(QANCollection_Key2BaseCol,Key2Type)
|
||||
DEFINE_BASECOLLECTION(QANCollection_BaseColFunc,ItemType)
|
||||
DEFINE_BASECOLLECTION(QANCollection_Key1BaseColFunc,Key1Type)
|
||||
DEFINE_BASECOLLECTION(QANCollection_Key2BaseColFunc,Key2Type)
|
||||
|
||||
#include <NCollection_DefineArray1.hxx>
|
||||
#include <NCollection_DefineHArray1.hxx>
|
||||
////////////////////////////////DEFINE_ARRAY1(QANCollection_Array1,QANCollection_BaseCol,ItemType)
|
||||
////////////////////////////////DEFINE_HARRAY1(QANCollection_HArray1,QANCollection_Array1)
|
||||
DEFINE_ARRAY1(QANCollection_Array1Func,QANCollection_BaseColFunc,ItemType)
|
||||
DEFINE_HARRAY1(QANCollection_HArray1Func,QANCollection_Array1Func)
|
||||
|
||||
#include <NCollection_DefineArray2.hxx>
|
||||
#include <NCollection_DefineHArray2.hxx>
|
||||
////////////////////////////////DEFINE_ARRAY2(QANCollection_Array2,QANCollection_BaseCol,ItemType)
|
||||
////////////////////////////////DEFINE_HARRAY2(QANCollection_HArray2,QANCollection_Array2)
|
||||
DEFINE_ARRAY2(QANCollection_Array2Func,QANCollection_BaseColFunc,ItemType)
|
||||
DEFINE_HARRAY2(QANCollection_HArray2Func,QANCollection_Array2Func)
|
||||
|
||||
#include <NCollection_DefineMap.hxx>
|
||||
#include <NCollection_DefineDataMap.hxx>
|
||||
#include <NCollection_DefineDoubleMap.hxx>
|
||||
#include <NCollection_DefineIndexedMap.hxx>
|
||||
#include <NCollection_DefineIndexedDataMap.hxx>
|
||||
////////////////////////////////DEFINE_MAP(QANCollection_Map,QANCollection_Key1BaseCol,Key1Type)
|
||||
////////////////////////////////DEFINE_DATAMAP(QANCollection_DataMap,QANCollection_BaseCol,Key1Type,ItemType)
|
||||
////////////////////////////////DEFINE_DOUBLEMAP(QANCollection_DoubleMap,QANCollection_Key2BaseCol,Key1Type,Key2Type)
|
||||
////////////////////////////////DEFINE_INDEXEDMAP(QANCollection_IndexedMap,QANCollection_Key1BaseCol,Key1Type)
|
||||
////////////////////////////////DEFINE_INDEXEDDATAMAP(QANCollection_IDMap,QANCollection_BaseCol,Key1Type,ItemType)
|
||||
DEFINE_MAP(QANCollection_MapFunc,QANCollection_Key1BaseColFunc,Key1Type)
|
||||
DEFINE_DATAMAP(QANCollection_DataMapFunc,QANCollection_BaseColFunc,Key1Type,ItemType)
|
||||
DEFINE_DOUBLEMAP(QANCollection_DoubleMapFunc,QANCollection_Key2BaseColFunc,Key1Type,Key2Type)
|
||||
DEFINE_INDEXEDMAP(QANCollection_IndexedMapFunc,QANCollection_Key1BaseColFunc,Key1Type)
|
||||
DEFINE_INDEXEDDATAMAP(QANCollection_IDMapFunc,QANCollection_BaseColFunc,Key1Type,ItemType)
|
||||
|
||||
#include <NCollection_DefineList.hxx>
|
||||
////////////////////////////////DEFINE_LIST(QANCollection_List,QANCollection_BaseCol,ItemType)
|
||||
DEFINE_LIST(QANCollection_ListFunc,QANCollection_BaseColFunc,ItemType)
|
||||
|
||||
#include <NCollection_DefineSequence.hxx>
|
||||
#include <NCollection_DefineHSequence.hxx>
|
||||
////////////////////////////////DEFINE_SEQUENCE(QANCollection_Sequence,QANCollection_BaseCol,ItemType)
|
||||
////////////////////////////////DEFINE_HSEQUENCE(QANCollection_HSequence,QANCollection_Sequence)
|
||||
DEFINE_SEQUENCE(QANCollection_SequenceFunc,QANCollection_BaseColFunc,ItemType)
|
||||
DEFINE_HSEQUENCE(QANCollection_HSequenceFunc,QANCollection_SequenceFunc)
|
||||
|
||||
|
||||
// ===================== Type independent methods =============================
|
||||
////////////////////////////////void printCollection (QANCollection_BaseCol& aColl,
|
||||
void printCollection (QANCollection_BaseColFunc& aColl,
|
||||
const char * str)
|
||||
{
|
||||
printf ("%s:\n",str);
|
||||
Standard_Integer iSize = aColl.Size();
|
||||
////////////////////////////////QANCollection_BaseCol::Iterator& anIter = aColl.CreateIterator();
|
||||
QANCollection_BaseColFunc::Iterator& anIter = aColl.CreateIterator();
|
||||
if (!anIter.More())
|
||||
{
|
||||
if (iSize==0)
|
||||
printf (" <Empty collection>\n");
|
||||
else
|
||||
printf ("Error : empty collection has size==%d",iSize);
|
||||
}
|
||||
else
|
||||
{
|
||||
printf (" Size==%d\n",iSize);
|
||||
for (; anIter.More(); anIter.Next())
|
||||
PrintItem(anIter.Value());
|
||||
}
|
||||
}
|
||||
|
||||
////////////////////////////////void printCollection (QANCollection_Key1BaseCol& aColl,
|
||||
#if 0
|
||||
void printCollection (QANCollection_Key1BaseColFunc& aColl,
|
||||
const char * str)
|
||||
{
|
||||
printf ("%s:\n",str);
|
||||
Standard_Integer iSize = aColl.Size();
|
||||
////////////////////////////////QANCollection_Key1BaseCol::Iterator& anIter = aColl.CreateIterator();
|
||||
QANCollection_Key1BaseColFunc::Iterator& anIter = aColl.CreateIterator();
|
||||
if (!anIter.More())
|
||||
{
|
||||
if (iSize==0)
|
||||
printf (" <Empty collection>\n");
|
||||
else
|
||||
printf ("Error : empty collection has size==%d",iSize);
|
||||
}
|
||||
else
|
||||
{
|
||||
printf (" Size==%d\n",iSize);
|
||||
for (; anIter.More(); anIter.Next())
|
||||
PrintItem(anIter.Value());
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
////////////////////////////////void printCollection (QANCollection_Key2BaseCol& aColl,
|
||||
void printCollection (QANCollection_Key2BaseColFunc& aColl,
|
||||
const char * str)
|
||||
{
|
||||
printf ("%s:\n",str);
|
||||
Standard_Integer iSize = aColl.Size();
|
||||
////////////////////////////////QANCollection_Key2BaseCol::Iterator& anIter = aColl.CreateIterator();
|
||||
QANCollection_Key2BaseColFunc::Iterator& anIter = aColl.CreateIterator();
|
||||
if (!anIter.More())
|
||||
{
|
||||
if (iSize==0)
|
||||
printf (" <Empty collection>\n");
|
||||
else
|
||||
printf ("Error : empty collection has size==%d",iSize);
|
||||
}
|
||||
else
|
||||
{
|
||||
printf (" Size==%d\n",iSize);
|
||||
for (; anIter.More(); anIter.Next())
|
||||
PrintItem(anIter.Value());
|
||||
}
|
||||
}
|
||||
|
||||
////////////////////////////////void AssignCollection (QANCollection_BaseCol& aCollSrc,
|
||||
//////////////////////////////// QANCollection_BaseCol& aCollDst)
|
||||
void AssignCollection (QANCollection_BaseColFunc& aCollSrc,
|
||||
QANCollection_BaseColFunc& aCollDst)
|
||||
{
|
||||
printCollection (aCollSrc,"Source collection");
|
||||
aCollDst.Assign(aCollSrc);
|
||||
printCollection (aCollDst,"Target collection");
|
||||
}
|
||||
|
||||
////////////////////////////////void AssignCollection (QANCollection_Key1BaseCol& aCollSrc,
|
||||
//////////////////////////////// QANCollection_Key1BaseCol& aCollDst)
|
||||
#if 0
|
||||
void AssignCollection (QANCollection_Key1BaseColFunc& aCollSrc,
|
||||
QANCollection_Key1BaseColFunc& aCollDst)
|
||||
{
|
||||
printCollection (aCollSrc,"Source collection");
|
||||
aCollDst.Assign(aCollSrc);
|
||||
printCollection (aCollDst,"Target collection");
|
||||
}
|
||||
#endif
|
||||
|
||||
////////////////////////////////void AssignCollection (QANCollection_Key2BaseCol& aCollSrc,
|
||||
//////////////////////////////// QANCollection_Key2BaseCol& aCollDst)
|
||||
void AssignCollection (QANCollection_Key2BaseColFunc& aCollSrc,
|
||||
QANCollection_Key2BaseColFunc& aCollDst)
|
||||
{
|
||||
printCollection (aCollSrc,"Source collection");
|
||||
aCollDst.Assign(aCollSrc);
|
||||
printCollection (aCollDst,"Target collection");
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@ -1,185 +0,0 @@
|
||||
// Created on: 2002-05-15
|
||||
// Created by: Alexander KARTOMIN (akm)
|
||||
// Copyright (c) 2002-2014 OPEN CASCADE SAS
|
||||
//
|
||||
// This file is part of Open CASCADE Technology software library.
|
||||
//
|
||||
// This library is free software; you can redistribute it and/or modify it under
|
||||
// the terms of the GNU Lesser General Public License version 2.1 as published
|
||||
// by the Free Software Foundation, with special exception defined in the file
|
||||
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
|
||||
// distribution for complete text of the license and disclaimer of any warranty.
|
||||
//
|
||||
// Alternatively, this file may be used under the terms of Open CASCADE
|
||||
// commercial license or contractual agreement.
|
||||
|
||||
#ifndef QANCollection_Common3_HeaderFile
|
||||
#define QANCollection_Common3_HeaderFile
|
||||
|
||||
#include <stdio.h>
|
||||
#include <gp_Pnt.hxx>
|
||||
|
||||
#include <QANCollection_Common.hxx>
|
||||
|
||||
// ===================== INSTANTIATIONS ===========
|
||||
// ===================== The Types must be defined before this line ===========
|
||||
// These are: TheItemType, TheKey1Type, TheKey2Type
|
||||
// So must be defined ::HashCode and ::IsEqual too
|
||||
|
||||
#if defined(ItemType) && defined(Key1Type) && defined(Key2Type)
|
||||
|
||||
#include <NCollection_DefineBaseCollection.hxx>
|
||||
////////////////////////////////DEFINE_BASECOLLECTION(QANCollection_BaseCol,ItemType)
|
||||
////////////////////////////////DEFINE_BASECOLLECTION(QANCollection_Key1BaseCol,Key1Type)
|
||||
////////////////////////////////DEFINE_BASECOLLECTION(QANCollection_Key2BaseCol,Key2Type)
|
||||
DEFINE_BASECOLLECTION(QANCollection_BaseColPerf,ItemType)
|
||||
DEFINE_BASECOLLECTION(QANCollection_Key1BaseColPerf,Key1Type)
|
||||
DEFINE_BASECOLLECTION(QANCollection_Key2BaseColPerf,Key2Type)
|
||||
|
||||
#include <NCollection_DefineArray1.hxx>
|
||||
#include <NCollection_DefineHArray1.hxx>
|
||||
////////////////////////////////DEFINE_ARRAY1(QANCollection_Array1,QANCollection_BaseCol,ItemType)
|
||||
////////////////////////////////DEFINE_HARRAY1(QANCollection_HArray1,QANCollection_Array1)
|
||||
DEFINE_ARRAY1(QANCollection_Array1Perf,QANCollection_BaseColPerf,ItemType)
|
||||
DEFINE_HARRAY1(QANCollection_HArray1Perf,QANCollection_Array1Perf)
|
||||
|
||||
#include <NCollection_DefineArray2.hxx>
|
||||
#include <NCollection_DefineHArray2.hxx>
|
||||
////////////////////////////////DEFINE_ARRAY2(QANCollection_Array2,QANCollection_BaseCol,ItemType)
|
||||
////////////////////////////////DEFINE_HARRAY2(QANCollection_HArray2,QANCollection_Array2)
|
||||
DEFINE_ARRAY2(QANCollection_Array2Perf,QANCollection_BaseColPerf,ItemType)
|
||||
DEFINE_HARRAY2(QANCollection_HArray2Perf,QANCollection_Array2Perf)
|
||||
|
||||
#include <NCollection_DefineMap.hxx>
|
||||
#include <NCollection_DefineDataMap.hxx>
|
||||
#include <NCollection_DefineDoubleMap.hxx>
|
||||
#include <NCollection_DefineIndexedMap.hxx>
|
||||
#include <NCollection_DefineIndexedDataMap.hxx>
|
||||
////////////////////////////////DEFINE_MAP(QANCollection_Map,QANCollection_Key1BaseCol,Key1Type)
|
||||
////////////////////////////////DEFINE_DATAMAP(QANCollection_DataMap,QANCollection_BaseCol,Key1Type,ItemType)
|
||||
////////////////////////////////DEFINE_DOUBLEMAP(QANCollection_DoubleMap,QANCollection_Key2BaseCol,Key1Type,Key2Type)
|
||||
////////////////////////////////DEFINE_INDEXEDMAP(QANCollection_IndexedMap,QANCollection_Key1BaseCol,Key1Type)
|
||||
////////////////////////////////DEFINE_INDEXEDDATAMAP(QANCollection_IDMap,QANCollection_BaseCol,Key1Type,ItemType)
|
||||
DEFINE_MAP(QANCollection_MapPerf,QANCollection_Key1BaseColPerf,Key1Type)
|
||||
DEFINE_DATAMAP(QANCollection_DataMapPerf,QANCollection_BaseColPerf,Key1Type,ItemType)
|
||||
DEFINE_DOUBLEMAP(QANCollection_DoubleMapPerf,QANCollection_Key2BaseColPerf,Key1Type,Key2Type)
|
||||
DEFINE_INDEXEDMAP(QANCollection_IndexedMapPerf,QANCollection_Key1BaseColPerf,Key1Type)
|
||||
DEFINE_INDEXEDDATAMAP(QANCollection_IDMapPerf,QANCollection_BaseColPerf,Key1Type,ItemType)
|
||||
|
||||
#include <NCollection_DefineList.hxx>
|
||||
////////////////////////////////DEFINE_LIST(QANCollection_List,QANCollection_BaseCol,ItemType)
|
||||
DEFINE_LIST(QANCollection_ListPerf,QANCollection_BaseColPerf,ItemType)
|
||||
|
||||
#include <NCollection_DefineSequence.hxx>
|
||||
#include <NCollection_DefineHSequence.hxx>
|
||||
////////////////////////////////DEFINE_SEQUENCE(QANCollection_Sequence,QANCollection_BaseCol,ItemType)
|
||||
////////////////////////////////DEFINE_HSEQUENCE(QANCollection_HSequence,QANCollection_Sequence)
|
||||
DEFINE_SEQUENCE(QANCollection_SequencePerf,QANCollection_BaseColPerf,ItemType)
|
||||
DEFINE_HSEQUENCE(QANCollection_HSequencePerf,QANCollection_SequencePerf)
|
||||
|
||||
|
||||
// ===================== Type independent methods =============================
|
||||
////////////////////////////////void printCollection (QANCollection_BaseCol& aColl,
|
||||
#if 0
|
||||
void printCollection (QANCollection_BaseColPerf& aColl,
|
||||
const char * str)
|
||||
{
|
||||
printf ("%s:\n",str);
|
||||
Standard_Integer iSize = aColl.Size();
|
||||
////////////////////////////////QANCollection_BaseCol::Iterator& anIter = aColl.CreateIterator();
|
||||
QANCollection_BaseColPerf::Iterator& anIter = aColl.CreateIterator();
|
||||
if (!anIter.More())
|
||||
{
|
||||
if (iSize==0)
|
||||
printf (" <Empty collection>\n");
|
||||
else
|
||||
printf ("Error : empty collection has size==%d",iSize);
|
||||
}
|
||||
else
|
||||
{
|
||||
printf (" Size==%d\n",iSize);
|
||||
for (; anIter.More(); anIter.Next())
|
||||
PrintItem(anIter.Value());
|
||||
}
|
||||
}
|
||||
|
||||
////////////////////////////////void printCollection (QANCollection_Key1BaseCol& aColl,
|
||||
void printCollection (QANCollection_Key1BaseColPerf& aColl,
|
||||
const char * str)
|
||||
{
|
||||
printf ("%s:\n",str);
|
||||
Standard_Integer iSize = aColl.Size();
|
||||
////////////////////////////////QANCollection_Key1BaseCol::Iterator& anIter = aColl.CreateIterator();
|
||||
QANCollection_Key1BaseColPerf::Iterator& anIter = aColl.CreateIterator();
|
||||
if (!anIter.More())
|
||||
{
|
||||
if (iSize==0)
|
||||
printf (" <Empty collection>\n");
|
||||
else
|
||||
printf ("Error : empty collection has size==%d",iSize);
|
||||
}
|
||||
else
|
||||
{
|
||||
printf (" Size==%d\n",iSize);
|
||||
for (; anIter.More(); anIter.Next())
|
||||
PrintItem(anIter.Value());
|
||||
}
|
||||
}
|
||||
|
||||
////////////////////////////////void printCollection (QANCollection_Key2BaseCol& aColl,
|
||||
void printCollection (QANCollection_Key2BaseColPerf& aColl,
|
||||
const char * str)
|
||||
{
|
||||
printf ("%s:\n",str);
|
||||
Standard_Integer iSize = aColl.Size();
|
||||
////////////////////////////////QANCollection_Key2BaseCol::Iterator& anIter = aColl.CreateIterator();
|
||||
QANCollection_Key2BaseColPerf::Iterator& anIter = aColl.CreateIterator();
|
||||
if (!anIter.More())
|
||||
{
|
||||
if (iSize==0)
|
||||
printf (" <Empty collection>\n");
|
||||
else
|
||||
printf ("Error : empty collection has size==%d",iSize);
|
||||
}
|
||||
else
|
||||
{
|
||||
printf (" Size==%d\n",iSize);
|
||||
for (; anIter.More(); anIter.Next())
|
||||
PrintItem(anIter.Value());
|
||||
}
|
||||
}
|
||||
|
||||
////////////////////////////////void AssignCollection (QANCollection_BaseCol& aCollSrc,
|
||||
//////////////////////////////// QANCollection_BaseCol& aCollDst)
|
||||
void AssignCollection (QANCollection_BaseColPerf& aCollSrc,
|
||||
QANCollection_BaseColPerf& aCollDst)
|
||||
{
|
||||
printCollection (aCollSrc,"Source collection");
|
||||
aCollDst.Assign(aCollSrc);
|
||||
printCollection (aCollDst,"Target collection");
|
||||
}
|
||||
|
||||
////////////////////////////////void AssignCollection (QANCollection_Key1BaseCol& aCollSrc,
|
||||
//////////////////////////////// QANCollection_Key1BaseCol& aCollDst)
|
||||
void AssignCollection (QANCollection_Key1BaseColPerf& aCollSrc,
|
||||
QANCollection_Key1BaseColPerf& aCollDst)
|
||||
{
|
||||
printCollection (aCollSrc,"Source collection");
|
||||
aCollDst.Assign(aCollSrc);
|
||||
printCollection (aCollDst,"Target collection");
|
||||
}
|
||||
|
||||
////////////////////////////////void AssignCollection (QANCollection_Key2BaseCol& aCollSrc,
|
||||
//////////////////////////////// QANCollection_Key2BaseCol& aCollDst)
|
||||
void AssignCollection (QANCollection_Key2BaseColPerf& aCollSrc,
|
||||
QANCollection_Key2BaseColPerf& aCollDst)
|
||||
{
|
||||
printCollection (aCollSrc,"Source collection");
|
||||
aCollDst.Assign(aCollSrc);
|
||||
printCollection (aCollDst,"Target collection");
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@ -1,92 +0,0 @@
|
||||
// Created on: 2002-04-30
|
||||
// Created by: Alexander KARTOMIN (akm)
|
||||
// Copyright (c) 2002-2014 OPEN CASCADE SAS
|
||||
//
|
||||
// This file is part of Open CASCADE Technology software library.
|
||||
//
|
||||
// This library is free software; you can redistribute it and/or modify it under
|
||||
// the terms of the GNU Lesser General Public License version 2.1 as published
|
||||
// by the Free Software Foundation, with special exception defined in the file
|
||||
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
|
||||
// distribution for complete text of the license and disclaimer of any warranty.
|
||||
//
|
||||
// Alternatively, this file may be used under the terms of Open CASCADE
|
||||
// commercial license or contractual agreement.
|
||||
|
||||
#ifndef QANCollection_FuncArrays_HeaderFile
|
||||
#define QANCollection_FuncArrays_HeaderFile
|
||||
|
||||
// ===================== Test methods of Array1 type ==========================
|
||||
////////////////////////////////void TestArray1 (QANCollection_Array1& theA1)
|
||||
void TestArray1 (QANCollection_Array1Func& theA1)
|
||||
{
|
||||
// Bounds
|
||||
Standard_Integer iLow=theA1.Lower();
|
||||
Standard_Integer iUpp=theA1.Upper();
|
||||
Standard_Integer i;
|
||||
|
||||
printf ("Info: testing Array1(%d,%d), %s\n",
|
||||
iLow, iUpp, (theA1.IsDeletable()?"deletable":"frozen"));
|
||||
// C-array constructor, Length, Init
|
||||
ItemType anItem;
|
||||
Random(anItem);
|
||||
theA1.Init (anItem);
|
||||
ItemType * rBlock = new ItemType[theA1.Length()];
|
||||
////////////////////////////////QANCollection_Array1 aCArr(*rBlock, iLow-100, iUpp-100);
|
||||
QANCollection_Array1Func aCArr(*rBlock, iLow-100, iUpp-100);
|
||||
printf (" created the same sized preallocated array (%d,%d), %s\n",
|
||||
aCArr.Lower(),aCArr.Upper(),(aCArr.IsDeletable()?"deletable":"frozen"));
|
||||
// *Value, operator()
|
||||
for (i=iLow+1; i<iUpp; i++)
|
||||
{
|
||||
Random (aCArr.ChangeValue (i-101));
|
||||
aCArr.SetValue (i-100, ItemType(aCArr.Value(i-101)));
|
||||
aCArr(i-99) = aCArr(i-100) = aCArr(i-101);
|
||||
}
|
||||
// Handle, copy constructor (including operator=)
|
||||
////////////////////////////////Handle(QANCollection_HArray1) aHa = new QANCollection_HArray1(aCArr);
|
||||
Handle(QANCollection_HArray1Func) aHa = new QANCollection_HArray1Func(aCArr);
|
||||
// Assign
|
||||
AssignCollection (aHa->ChangeArray1(), theA1);
|
||||
}
|
||||
|
||||
// ===================== Test methods of Array2 type ==========================
|
||||
////////////////////////////////void TestArray2 (QANCollection_Array2& theA2)
|
||||
void TestArray2 (QANCollection_Array2Func& theA2)
|
||||
{
|
||||
// Bounds
|
||||
Standard_Integer iLR=theA2.LowerRow(), iLC=theA2.LowerCol();
|
||||
Standard_Integer iUR=theA2.UpperRow(), iUC=theA2.UpperCol();
|
||||
Standard_Integer i,j;
|
||||
|
||||
printf ("Info: testing Array2 (%d,%d)(%d,%d), %s\n",
|
||||
iLR, iUR, iLC, iUC, (theA2.IsDeletable()?"deletable":"frozen"));
|
||||
// C-array constructor, Length, Init, RowLength, ColLength
|
||||
ItemType anItem;
|
||||
Random(anItem);
|
||||
theA2.Init (anItem);
|
||||
ItemType * rBlock = new ItemType[theA2.Length()];
|
||||
////////////////////////////////QANCollection_Array2 aCArr(*rBlock, iLR-100, iUR-100, iLC, iUC);
|
||||
QANCollection_Array2Func aCArr(*rBlock, iLR-100, iUR-100, iLC, iUC);
|
||||
printf (" created the same sized preallocated array (%d*%d), %s\n",
|
||||
aCArr.RowLength(), aCArr.ColLength(),
|
||||
(aCArr.IsDeletable()?"deletable":"frozen"));
|
||||
// *Value, operator()
|
||||
for (i=iLR+1; i<iUR; i++)
|
||||
{
|
||||
for (j=iLC; j<=iUC; j++)
|
||||
{
|
||||
Random (aCArr.ChangeValue (i-101, j));
|
||||
aCArr.SetValue (i-100, j,
|
||||
ItemType(aCArr.Value(i-101,j)));
|
||||
aCArr(i-99,j) = aCArr(i-100,j) = aCArr(i-101,j);
|
||||
}
|
||||
}
|
||||
// Handle, copy constructor (including operator=)
|
||||
////////////////////////////////Handle(QANCollection_HArray2) aHa = new QANCollection_HArray2(aCArr);
|
||||
Handle(QANCollection_HArray2Func) aHa = new QANCollection_HArray2Func(aCArr);
|
||||
// Assign
|
||||
AssignCollection (aHa->ChangeArray2(), theA2);
|
||||
}
|
||||
|
||||
#endif
|
||||
@ -1,129 +0,0 @@
|
||||
// Created on: 2002-04-30
|
||||
// Created by: Alexander KARTOMIN (akm)
|
||||
// Copyright (c) 2002-2014 OPEN CASCADE SAS
|
||||
//
|
||||
// This file is part of Open CASCADE Technology software library.
|
||||
//
|
||||
// This library is free software; you can redistribute it and/or modify it under
|
||||
// the terms of the GNU Lesser General Public License version 2.1 as published
|
||||
// by the Free Software Foundation, with special exception defined in the file
|
||||
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
|
||||
// distribution for complete text of the license and disclaimer of any warranty.
|
||||
//
|
||||
// Alternatively, this file may be used under the terms of Open CASCADE
|
||||
// commercial license or contractual agreement.
|
||||
|
||||
#ifndef QANCollection_FuncLists_HeaderFile
|
||||
#define QANCollection_FuncLists_HeaderFile
|
||||
|
||||
// ===================== Test methods of List type ==========================
|
||||
////////////////////////////////void TestList (QANCollection_List& theL)
|
||||
void TestList (QANCollection_ListFunc& theL)
|
||||
{
|
||||
// Extent
|
||||
Standard_Integer iExt=theL.Extent();
|
||||
Standard_Integer i;
|
||||
|
||||
printf ("Info: testing List(%d)\n", iExt);
|
||||
// Append(2), Prepend(2), InsertBefore(2), InsertAfter(2),
|
||||
// Remove, RemoveFirst, First, Last
|
||||
ItemType anItem;
|
||||
////////////////////////////////QANCollection_List aL, aL1;
|
||||
QANCollection_ListFunc aL, aL1;
|
||||
for (i=0; i<4; i++)
|
||||
{
|
||||
Random (anItem);
|
||||
aL.Append (anItem); // #1
|
||||
aL.Append (aL1); // #2
|
||||
Random (anItem);
|
||||
aL1.Prepend (anItem); // #3
|
||||
aL1.Prepend (aL); // #4
|
||||
////////////////////////////////QANCollection_List::Iterator anI(theL);
|
||||
QANCollection_ListFunc::Iterator anI(theL);
|
||||
if (anI.More())
|
||||
{
|
||||
Random (anItem);
|
||||
theL.InsertBefore (anItem, anI); // #5
|
||||
theL.InsertBefore (aL1, anI); // #6
|
||||
Random (anItem);
|
||||
theL.InsertAfter (anItem, anI); // #7
|
||||
theL.InsertAfter (aL, anI); // #8
|
||||
theL.Remove (anI); // #9
|
||||
if (theL.Extent() > 0)
|
||||
theL.RemoveFirst(); // #10
|
||||
}
|
||||
else
|
||||
{
|
||||
theL.Prepend (anItem);
|
||||
PrintItem(theL.First());
|
||||
PrintItem(theL.Last());
|
||||
}
|
||||
}
|
||||
// Copy constructor + operator=
|
||||
////////////////////////////////aL = QANCollection_List(theL);
|
||||
aL = QANCollection_ListFunc(theL);
|
||||
|
||||
// Assign
|
||||
AssignCollection (theL, aL);
|
||||
|
||||
// Clear
|
||||
aL.Clear();
|
||||
}
|
||||
|
||||
// ===================== Test methods of Sequence type ========================
|
||||
////////////////////////////////void TestSequence (QANCollection_Sequence& theS)
|
||||
void TestSequence (QANCollection_SequenceFunc& theS)
|
||||
{
|
||||
Standard_Integer i;
|
||||
|
||||
printf ("Info: testing Sequence\n");
|
||||
// Append(2)
|
||||
ItemType anItem;
|
||||
////////////////////////////////QANCollection_Sequence aS, aS1;
|
||||
QANCollection_SequenceFunc aS, aS1;
|
||||
// Append(2), Prepend(2), InsertBefore(2), InsertAfter(2),
|
||||
// Remove, RemoveFirst, First, Last
|
||||
for (i=0; i<4; i++)
|
||||
{
|
||||
Random (anItem);
|
||||
aS.Append (anItem); // #1
|
||||
aS.Append (aS1); // #2
|
||||
Random (anItem);
|
||||
aS1.Prepend (anItem); // #3
|
||||
aS1.Prepend (aS); // #4
|
||||
if (theS.Length() > 0)
|
||||
{
|
||||
Random (anItem);
|
||||
theS.InsertBefore (1, anItem); // #5
|
||||
theS.InsertBefore (2, aS1); // #6
|
||||
Random (anItem);
|
||||
theS.InsertAfter (1, anItem); // #7
|
||||
theS.InsertAfter (2, aS); // #8
|
||||
theS.Remove (1); // #9
|
||||
if (theS.Length() > 0)
|
||||
theS.Remove(1); // #10
|
||||
}
|
||||
else
|
||||
{
|
||||
theS.Prepend (anItem);
|
||||
PrintItem(theS.First());
|
||||
PrintItem(theS.Last());
|
||||
}
|
||||
}
|
||||
|
||||
// ()
|
||||
PrintItem(theS(1));
|
||||
|
||||
// Handle, Split
|
||||
////////////////////////////////Handle(QANCollection_HSequence) aHS = new QANCollection_HSequence(aS1);
|
||||
Handle(QANCollection_HSequenceFunc) aHS = new QANCollection_HSequenceFunc(aS1);
|
||||
theS.Split (3, aHS->ChangeSequence());
|
||||
|
||||
// Assign
|
||||
AssignCollection (theS, aS);
|
||||
|
||||
// Clear
|
||||
aS.Clear();
|
||||
}
|
||||
|
||||
#endif
|
||||
@ -1,287 +0,0 @@
|
||||
// Created on: 2002-04-30
|
||||
// Created by: Alexander KARTOMIN (akm)
|
||||
// Copyright (c) 2002-2014 OPEN CASCADE SAS
|
||||
//
|
||||
// This file is part of Open CASCADE Technology software library.
|
||||
//
|
||||
// This library is free software; you can redistribute it and/or modify it under
|
||||
// the terms of the GNU Lesser General Public License version 2.1 as published
|
||||
// by the Free Software Foundation, with special exception defined in the file
|
||||
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
|
||||
// distribution for complete text of the license and disclaimer of any warranty.
|
||||
//
|
||||
// Alternatively, this file may be used under the terms of Open CASCADE
|
||||
// commercial license or contractual agreement.
|
||||
|
||||
#ifndef QANCollection_FuncMaps_HeaderFile
|
||||
#define QANCollection_FuncMaps_HeaderFile
|
||||
|
||||
// ===================== Test methods of Map type =============================
|
||||
////////////////////////////////void TestMap (QANCollection_Map& theM)
|
||||
void TestMap (QANCollection_MapFunc& theM)
|
||||
{
|
||||
// Extent
|
||||
Standard_Integer iExt=theM.Extent();
|
||||
Standard_Integer i;
|
||||
|
||||
printf ("Info: testing Map(l=%d)\n", iExt);
|
||||
theM.Statistics(cout);
|
||||
// Resize
|
||||
theM.ReSize(8);
|
||||
theM.Statistics(cout);
|
||||
cout.flush();
|
||||
// Constructor
|
||||
////////////////////////////////QANCollection_Map aM;
|
||||
QANCollection_MapFunc aM;
|
||||
// Add
|
||||
Key1Type aKey;
|
||||
for (i=0; i<8; i++)
|
||||
{
|
||||
Random (aKey);
|
||||
aM.Add (aKey);
|
||||
}
|
||||
// Contains, Remove
|
||||
if (!aM.Contains(aKey))
|
||||
{
|
||||
printf("Error : map says that it does not contain its key ");
|
||||
PrintItem(aKey);
|
||||
}
|
||||
else
|
||||
{
|
||||
aM.Remove(aKey);
|
||||
printf(" successfully removed item, l=%d\n", aM.Size());
|
||||
}
|
||||
// Copy constructor (including operator=)
|
||||
////////////////////////////////QANCollection_Map aM2 = QANCollection_Map(aM);
|
||||
QANCollection_MapFunc aM2 = QANCollection_MapFunc(aM);
|
||||
// Assign
|
||||
AssignCollection (aM2,theM);
|
||||
|
||||
// Clear
|
||||
aM.Clear();
|
||||
}
|
||||
|
||||
// ===================== Test methods of DataMap type =========================
|
||||
////////////////////////////////void TestDataMap (QANCollection_DataMap& theM)
|
||||
void TestDataMap (QANCollection_DataMapFunc& theM)
|
||||
{
|
||||
// Extent
|
||||
Standard_Integer iExt=theM.Extent();
|
||||
Standard_Integer i;
|
||||
|
||||
printf ("Info: testing DataMap(l=%d)\n", iExt);
|
||||
theM.Statistics(cout);
|
||||
// Resize
|
||||
theM.ReSize(8);
|
||||
theM.Statistics(cout);
|
||||
cout.flush();
|
||||
// Constructor
|
||||
////////////////////////////////QANCollection_DataMap aM;
|
||||
QANCollection_DataMapFunc aM;
|
||||
// Bind, Find, ChangeFind, ()
|
||||
Key1Type aKey;
|
||||
ItemType anItem;
|
||||
for (i=0; i<8; i++)
|
||||
{
|
||||
Random (aKey);
|
||||
Random (anItem);
|
||||
aM.Bind (aKey, anItem);
|
||||
PrintItem(aM.Find(aKey));
|
||||
Random(aM(aKey));
|
||||
}
|
||||
// IsBound, UnBind
|
||||
if (!aM.IsBound(aKey))
|
||||
{
|
||||
printf("Error : map says that it does not contain its key ");
|
||||
PrintItem(aKey);
|
||||
}
|
||||
else
|
||||
{
|
||||
aM.UnBind(aKey);
|
||||
printf(" successfully unbound the key, l=%d\n", aM.Size());
|
||||
}
|
||||
// Copy constructor (including operator=)
|
||||
////////////////////////////////theM = QANCollection_DataMap(aM);
|
||||
theM = QANCollection_DataMapFunc(aM);
|
||||
// Assign - prohibited
|
||||
// AssignCollection (aM2,theM);
|
||||
printCollection (theM, "DataMap:");
|
||||
|
||||
// Clear
|
||||
aM.Clear();
|
||||
}
|
||||
|
||||
|
||||
// ===================== Test methods of DoubleMap type =======================
|
||||
////////////////////////////////void TestDoubleMap (QANCollection_DoubleMap& theM)
|
||||
void TestDoubleMap (QANCollection_DoubleMapFunc& theM)
|
||||
{
|
||||
// Extent
|
||||
Standard_Integer iExt=theM.Extent();
|
||||
Standard_Integer i;
|
||||
|
||||
printf ("Info: testing DoubleMap(l=%d)\n", iExt);
|
||||
theM.Statistics(cout);
|
||||
// Resize
|
||||
theM.ReSize(8);
|
||||
theM.Statistics(cout);
|
||||
cout.flush();
|
||||
// Constructor
|
||||
////////////////////////////////QANCollection_DoubleMap aM;
|
||||
QANCollection_DoubleMapFunc aM;
|
||||
// Bind, Find?,
|
||||
Key1Type aKey1;
|
||||
Key2Type aKey2;
|
||||
for (i=0; i<8; i++)
|
||||
{
|
||||
Random (aKey1);
|
||||
Random (aKey2);
|
||||
aM.Bind (aKey1, aKey2);
|
||||
PrintItem(aM.Find1(aKey1));
|
||||
if (!aM.IsBound1(aKey1))
|
||||
{
|
||||
printf("Error : map says that it does not contain its key ");
|
||||
PrintItem(aKey1);
|
||||
}
|
||||
PrintItem(aM.Find2(aKey2));
|
||||
if (!aM.IsBound2(aKey2))
|
||||
{
|
||||
printf("Error : map says that it does not contain its key ");
|
||||
PrintItem(aKey2);
|
||||
}
|
||||
}
|
||||
// AreBound, UnBind
|
||||
if (!aM.AreBound(aKey1,aKey2))
|
||||
{
|
||||
printf("Error : map says that it does not contain its keys ");
|
||||
PrintItem(aKey1);
|
||||
PrintItem(aKey2);
|
||||
}
|
||||
else
|
||||
{
|
||||
if (aM.UnBind2(aKey2))
|
||||
printf(" successfully unbound the key, l=%d\n", aM.Size());
|
||||
if (aM.UnBind1(aKey1))
|
||||
printf("Error : unbound both keys?!\n");
|
||||
}
|
||||
// Copy constructor (including operator=)
|
||||
////////////////////////////////theM = QANCollection_DoubleMap(aM);
|
||||
theM = QANCollection_DoubleMapFunc(aM);
|
||||
// Assign - prohibited
|
||||
// AssignCollection (aM2,theM);
|
||||
printCollection (theM, "DoubleMap:");
|
||||
|
||||
// Clear
|
||||
aM.Clear();
|
||||
}
|
||||
|
||||
// ===================== Test methods of IndexedMap type ======================
|
||||
////////////////////////////////void TestIndexedMap (QANCollection_IndexedMap& theM)
|
||||
void TestIndexedMap (QANCollection_IndexedMapFunc& theM)
|
||||
{
|
||||
// Extent
|
||||
Standard_Integer iExt=theM.Extent();
|
||||
Standard_Integer i;
|
||||
|
||||
printf ("Info: testing IndexedMap(l=%d)\n", iExt);
|
||||
theM.Statistics(cout);
|
||||
// Resize
|
||||
theM.ReSize(8);
|
||||
theM.Statistics(cout);
|
||||
cout.flush();
|
||||
// Constructor
|
||||
////////////////////////////////QANCollection_IndexedMap aM;
|
||||
QANCollection_IndexedMapFunc aM;
|
||||
// Add, FindKey, FindIndex
|
||||
Key1Type aKey;
|
||||
for (i=0; i<8; i++)
|
||||
{
|
||||
Random (aKey);
|
||||
aM.Add (aKey);
|
||||
Standard_Integer iIndex=aM.FindIndex(aKey);
|
||||
printf (" added a key, i=%d, k=",iIndex);
|
||||
PrintItem(aM(iIndex));
|
||||
}
|
||||
// Contains, Remove
|
||||
if (!aM.Contains(aM.FindKey(aM.FindIndex(aKey))))
|
||||
{
|
||||
printf("Error : map says that it does not contain its key ");
|
||||
PrintItem(aKey);
|
||||
}
|
||||
else
|
||||
{
|
||||
aM.RemoveLast();
|
||||
printf(" successfully removed item, l=%d\n", aM.Size());
|
||||
}
|
||||
// Substitute
|
||||
Random(aKey);
|
||||
aM.Substitute(1,aKey);
|
||||
// Copy constructor (including operator=)
|
||||
////////////////////////////////QANCollection_IndexedMap aM2 = QANCollection_IndexedMap(aM);
|
||||
QANCollection_IndexedMapFunc aM2 = QANCollection_IndexedMapFunc(aM);
|
||||
// Assign
|
||||
AssignCollection (aM2,theM);
|
||||
|
||||
// Clear
|
||||
aM.Clear();
|
||||
}
|
||||
|
||||
// ===================== Test methods of IndexedDataMap type ==================
|
||||
////////////////////////////////void TestIndexedDataMap (QANCollection_IDMap& theM)
|
||||
void TestIndexedDataMap (QANCollection_IDMapFunc& theM)
|
||||
{
|
||||
// Extent
|
||||
Standard_Integer iExt=theM.Extent();
|
||||
Standard_Integer i;
|
||||
|
||||
printf ("Info: testing IndexedDataMap(l=%d)\n", iExt);
|
||||
theM.Statistics(cout);
|
||||
// Resize
|
||||
theM.ReSize(8);
|
||||
theM.Statistics(cout);
|
||||
cout.flush();
|
||||
// Constructor
|
||||
////////////////////////////////QANCollection_IDMap aM;
|
||||
QANCollection_IDMapFunc aM;
|
||||
// Add, FindKey, FindIndex, FindFromIndex, Change..., ()
|
||||
Key1Type aKey;
|
||||
ItemType anItem;
|
||||
for (i=0; i<8; i++)
|
||||
{
|
||||
Random (aKey);
|
||||
Random (anItem);
|
||||
aM.Add (aKey, anItem);
|
||||
Standard_Integer iIndex=aM.FindIndex(aKey);
|
||||
printf (" added a key, i=%d, k=",iIndex);
|
||||
PrintItem(aM.FindKey(iIndex));
|
||||
PrintItem(aM(iIndex));
|
||||
Random(aM.ChangeFromIndex(iIndex));
|
||||
}
|
||||
// Contains, Remove, FindFromKey
|
||||
if (!aM.Contains(aM.FindKey(aM.FindIndex(aKey))))
|
||||
{
|
||||
printf("Error : map says that it does not contain its key ");
|
||||
PrintItem(aKey);
|
||||
}
|
||||
else
|
||||
{
|
||||
anItem = aM.FindFromKey(aKey);
|
||||
aM.RemoveLast();
|
||||
printf(" successfully removed item, l=%d\n", aM.Size());
|
||||
}
|
||||
// Substitute
|
||||
Random(aKey);
|
||||
aM.Substitute (1, aKey, anItem);
|
||||
// Copy constructor (including operator=)
|
||||
////////////////////////////////theM = QANCollection_IDMap(aM);
|
||||
theM = QANCollection_IDMapFunc(aM);
|
||||
// Assign - prohibited
|
||||
// AssignCollection (aM2,theM);
|
||||
printCollection (theM, "DoubleMap:");
|
||||
|
||||
// Clear
|
||||
aM.Clear();
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
@ -1,40 +0,0 @@
|
||||
// Created on: 2002-04-30
|
||||
// Created by: Alexander KARTOMIN (akm)
|
||||
// Copyright (c) 2002-2014 OPEN CASCADE SAS
|
||||
//
|
||||
// This file is part of Open CASCADE Technology software library.
|
||||
//
|
||||
// This library is free software; you can redistribute it and/or modify it under
|
||||
// the terms of the GNU Lesser General Public License version 2.1 as published
|
||||
// by the Free Software Foundation, with special exception defined in the file
|
||||
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
|
||||
// distribution for complete text of the license and disclaimer of any warranty.
|
||||
//
|
||||
// Alternatively, this file may be used under the terms of Open CASCADE
|
||||
// commercial license or contractual agreement.
|
||||
|
||||
// Purpose: To test all methods of all NCollection classes
|
||||
|
||||
#ifndef QANCollection_FuncTest_HeaderFile
|
||||
#define QANCollection_FuncTest_HeaderFile
|
||||
|
||||
#include <QANCollection_Common2.hxx>
|
||||
|
||||
// ===================== Test methods for each type ===========================
|
||||
// Parameters of funcs below must be empty collections
|
||||
|
||||
// Standard_EXPORT void TestArray1 (QANCollection_Array1& theA1);
|
||||
// Standard_EXPORT void TestArray2 (QANCollection_Array2& theA2);
|
||||
#include <QANCollection_FuncArrays.hxx>
|
||||
// Standard_EXPORT void TestMap (QANCollection_Map& theM );
|
||||
// Standard_EXPORT void TestDataMap (QANCollection_DataMap& theDM);
|
||||
// Standard_EXPORT void TestDblMap (QANCollection_DoubleMap& theBM);
|
||||
// Standard_EXPORT void TestIndyMap (QANCollection_IndexedMap& theIM);
|
||||
// Standard_EXPORT void TestInDaMap (QANCollection_IDMap& theNM);
|
||||
// Standard_EXPORT void TestInDaMap (QANCollection_IDMap& theNM);
|
||||
#include <QANCollection_FuncMaps.hxx>
|
||||
// Standard_EXPORT void TestList (QANCollection_List& theLi);
|
||||
// Standard_EXPORT void TestSequence(QANCollection_Sequence& theSq);
|
||||
#include <QANCollection_FuncLists.hxx>
|
||||
|
||||
#endif
|
||||
1156
src/QANCollection/QANCollection_Perf.cxx
Normal file
1156
src/QANCollection/QANCollection_Perf.cxx
Normal file
File diff suppressed because it is too large
Load Diff
@ -1,196 +0,0 @@
|
||||
// Created on: 2002-05-15
|
||||
// Created by: Alexander KARTOMIN (akm)
|
||||
// Copyright (c) 2002-2014 OPEN CASCADE SAS
|
||||
//
|
||||
// This file is part of Open CASCADE Technology software library.
|
||||
//
|
||||
// This library is free software; you can redistribute it and/or modify it under
|
||||
// the terms of the GNU Lesser General Public License version 2.1 as published
|
||||
// by the Free Software Foundation, with special exception defined in the file
|
||||
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
|
||||
// distribution for complete text of the license and disclaimer of any warranty.
|
||||
//
|
||||
// Alternatively, this file may be used under the terms of Open CASCADE
|
||||
// commercial license or contractual agreement.
|
||||
|
||||
#ifndef QANCollection_PerfArrays_HeaderFile
|
||||
#define QANCollection_PerfArrays_HeaderFile
|
||||
|
||||
#define PERF_ENABLE_METERS
|
||||
#include <OSD_PerfMeter.hxx>
|
||||
////////////////////////////////#include <Perf_Meter.hxx>
|
||||
#include <TColgp_Array1OfPnt.hxx>
|
||||
#include <TColgp_Array2OfPnt.hxx>
|
||||
|
||||
// ===================== Test perform of Array1 type ==========================
|
||||
void CompArray1 (const Standard_Integer theRep,
|
||||
const Standard_Integer theSize)
|
||||
{
|
||||
Standard_Integer i,j;
|
||||
|
||||
////////////////////////////////Perf_Meter aNCrea ("NCollection_Array1 creation",0);
|
||||
////////////////////////////////Perf_Meter aTCrea ("TCollection_Array1 creation",0);
|
||||
////////////////////////////////Perf_Meter aNFill ("NCollection_Array1 filling",0);
|
||||
////////////////////////////////Perf_Meter aTFill ("TCollection_Array1 filling",0);
|
||||
////////////////////////////////Perf_Meter aNFind ("NCollection_Array1 finding",0);
|
||||
////////////////////////////////Perf_Meter aTFind ("TCollection_Array1 finding",0);
|
||||
////////////////////////////////Perf_Meter aNOper ("NCollection_Array1 operator=",0);
|
||||
////////////////////////////////Perf_Meter aTOper ("TCollection_Array1 operator=",0);
|
||||
////////////////////////////////Perf_Meter aNAssi ("NCollection_Array1 Assign",0);
|
||||
for (i=0; i<theRep; i++)
|
||||
{
|
||||
////////////////////////////////aNCrea.Start();
|
||||
PERF_START_METER("NCollection_Array1 creation")
|
||||
////////////////////////////////QANCollection_Array1 a1(1,theSize), a2(1,theSize);
|
||||
QANCollection_Array1Perf a1(1,theSize), a2(1,theSize);
|
||||
////////////////////////////////aNCrea.Stop();
|
||||
PERF_STOP_METER("NCollection_Array1 creation")
|
||||
////////////////////////////////aNFill.Start();
|
||||
PERF_START_METER("NCollection_Array1 filling")
|
||||
for (j=1; j<=theSize; j++)
|
||||
Random(a1(j));
|
||||
////////////////////////////////aNFill.Stop();
|
||||
PERF_STOP_METER("NCollection_Array1 filling")
|
||||
////////////////////////////////aNFind.Start();
|
||||
PERF_START_METER("NCollection_Array1 finding")
|
||||
for (j=1; j<=theSize; j++)
|
||||
{
|
||||
Standard_Integer iIndex;
|
||||
Random(iIndex,theSize);
|
||||
a1.Value(iIndex+1);
|
||||
}
|
||||
////////////////////////////////aNFind.Stop();
|
||||
PERF_STOP_METER("NCollection_Array1 finding")
|
||||
////////////////////////////////aNOper.Start();
|
||||
PERF_START_METER("NCollection_Array1 operator=")
|
||||
a2 = a1;
|
||||
////////////////////////////////aNOper.Stop();
|
||||
PERF_STOP_METER("NCollection_Array1 operator=")
|
||||
////////////////////////////////aNAssi.Start();
|
||||
PERF_START_METER("NCollection_Array1 Assign")
|
||||
a2.Assign(a1);
|
||||
////////////////////////////////aNAssi.Stop();
|
||||
PERF_STOP_METER("NCollection_Array1 Assign")
|
||||
}
|
||||
|
||||
for (i=0; i<theRep; i++)
|
||||
{
|
||||
////////////////////////////////aTCrea.Start();
|
||||
PERF_START_METER("TCollection_Array1 creation")
|
||||
TColgp_Array1OfPnt a1(1,theSize), a2(1,theSize);
|
||||
////////////////////////////////aTCrea.Stop();
|
||||
PERF_STOP_METER("TCollection_Array1 creation")
|
||||
////////////////////////////////aTFill.Start();
|
||||
PERF_START_METER("TCollection_Array1 filling")
|
||||
for (j=1; j<=theSize; j++)
|
||||
Random(a1(j));
|
||||
////////////////////////////////aTFill.Stop();
|
||||
PERF_STOP_METER("TCollection_Array1 filling")
|
||||
////////////////////////////////aTFind.Start();
|
||||
PERF_START_METER("TCollection_Array1 finding")
|
||||
for (j=1; j<=theSize; j++)
|
||||
{
|
||||
Standard_Integer iIndex;
|
||||
Random(iIndex,theSize);
|
||||
a1.Value(iIndex+1);
|
||||
}
|
||||
////////////////////////////////aTFind.Stop();
|
||||
PERF_STOP_METER("TCollection_Array1 finding")
|
||||
////////////////////////////////aTOper.Start();
|
||||
PERF_START_METER("TCollection_Array1 operator=")
|
||||
a2 = a1;
|
||||
////////////////////////////////aTOper.Stop();
|
||||
PERF_STOP_METER("TCollection_Array1 operator=")
|
||||
}
|
||||
PERF_PRINT_ALL
|
||||
}
|
||||
|
||||
// ===================== Test perform of Array2 type ==========================
|
||||
void CompArray2 (const Standard_Integer theRep,
|
||||
const Standard_Integer theSize)
|
||||
{
|
||||
Standard_Integer i,j,k;
|
||||
|
||||
////////////////////////////////Perf_Meter aNCrea ("NCollection_Array2 creation",0);
|
||||
////////////////////////////////Perf_Meter aTCrea ("TCollection_Array2 creation",0);
|
||||
////////////////////////////////Perf_Meter aNFill ("NCollection_Array2 filling",0);
|
||||
////////////////////////////////Perf_Meter aTFill ("TCollection_Array2 filling",0);
|
||||
////////////////////////////////Perf_Meter aNFind ("NCollection_Array2 finding",0);
|
||||
////////////////////////////////Perf_Meter aTFind ("TCollection_Array2 finding",0);
|
||||
////////////////////////////////Perf_Meter aNOper ("NCollection_Array2 operator=",0);
|
||||
////////////////////////////////Perf_Meter aTOper ("TCollection_Array2 operator=",0);
|
||||
////////////////////////////////Perf_Meter aNAssi ("NCollection_Array2 Assign",0);
|
||||
for (i=0; i<theRep; i++)
|
||||
{
|
||||
////////////////////////////////aNCrea.Start();
|
||||
PERF_START_METER("NCollection_Array2 creation")
|
||||
////////////////////////////////QANCollection_Array2 a1(1,theSize,1,theSize), a2(1,theSize,1,theSize);
|
||||
QANCollection_Array2Perf a1(1,theSize,1,theSize), a2(1,theSize,1,theSize);
|
||||
////////////////////////////////aNCrea.Stop();
|
||||
PERF_STOP_METER("NCollection_Array2 creation")
|
||||
////////////////////////////////aNFill.Start();
|
||||
PERF_START_METER("NCollection_Array2 filling")
|
||||
for (j=1; j<=theSize; j++)
|
||||
for (k=1; k<=theSize; k++)
|
||||
Random(a1(j,k));
|
||||
////////////////////////////////aNFill.Stop();
|
||||
PERF_STOP_METER("NCollection_Array2 filling")
|
||||
////////////////////////////////aNFind.Start();
|
||||
PERF_START_METER("NCollection_Array2 finding")
|
||||
for (j=1; j<=theSize*theSize; j++)
|
||||
{
|
||||
Standard_Integer m,n;
|
||||
Random(m,theSize);
|
||||
Random(n,theSize);
|
||||
a1.Value(m+1,n+1);
|
||||
}
|
||||
////////////////////////////////aNFind.Stop();
|
||||
PERF_STOP_METER("NCollection_Array2 finding")
|
||||
////////////////////////////////aNOper.Start();
|
||||
PERF_START_METER("NCollection_Array2 operator=")
|
||||
a2 = a1;
|
||||
////////////////////////////////aNOper.Stop();
|
||||
PERF_STOP_METER("NCollection_Array2 operator=")
|
||||
////////////////////////////////aNAssi.Start();
|
||||
PERF_START_METER("NCollection_Array2 Assign")
|
||||
a2.Assign(a1);
|
||||
////////////////////////////////aNAssi.Stop();
|
||||
PERF_STOP_METER("NCollection_Array2 Assign")
|
||||
}
|
||||
|
||||
for (i=0; i<theRep; i++)
|
||||
{
|
||||
////////////////////////////////aTCrea.Start();
|
||||
PERF_START_METER("TCollection_Array2 creation")
|
||||
TColgp_Array2OfPnt a1(1,theSize,1,theSize), a2(1,theSize,1,theSize);
|
||||
////////////////////////////////aTCrea.Stop();
|
||||
PERF_STOP_METER("TCollection_Array2 creation")
|
||||
////////////////////////////////aTFill.Start();
|
||||
PERF_START_METER("TCollection_Array2 filling")
|
||||
for (j=1; j<=theSize; j++)
|
||||
for (k=1; k<=theSize; k++)
|
||||
Random(a1(j,k));
|
||||
////////////////////////////////aTFill.Stop();
|
||||
PERF_STOP_METER("TCollection_Array2 filling")
|
||||
////////////////////////////////aTFind.Start();
|
||||
PERF_START_METER("TCollection_Array2 finding")
|
||||
for (j=1; j<=theSize*theSize; j++)
|
||||
{
|
||||
Standard_Integer m,n;
|
||||
Random(m,theSize);
|
||||
Random(n,theSize);
|
||||
a1.Value(m+1,n+1);
|
||||
}
|
||||
////////////////////////////////aTFind.Stop();
|
||||
PERF_STOP_METER("TCollection_Array2 finding")
|
||||
////////////////////////////////aTOper.Start();
|
||||
PERF_START_METER("TCollection_Array2 operator=")
|
||||
a2 = a1;
|
||||
////////////////////////////////aTOper.Stop();
|
||||
PERF_STOP_METER("TCollection_Array2 operator=")
|
||||
}
|
||||
PERF_PRINT_ALL
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
@ -1,188 +0,0 @@
|
||||
// Created on: 2002-04-30
|
||||
// Created by: Alexander KARTOMIN (akm)
|
||||
// Copyright (c) 2002-2014 OPEN CASCADE SAS
|
||||
//
|
||||
// This file is part of Open CASCADE Technology software library.
|
||||
//
|
||||
// This library is free software; you can redistribute it and/or modify it under
|
||||
// the terms of the GNU Lesser General Public License version 2.1 as published
|
||||
// by the Free Software Foundation, with special exception defined in the file
|
||||
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
|
||||
// distribution for complete text of the license and disclaimer of any warranty.
|
||||
//
|
||||
// Alternatively, this file may be used under the terms of Open CASCADE
|
||||
// commercial license or contractual agreement.
|
||||
|
||||
#ifndef QANCollection_PerfLists_HeaderFile
|
||||
#define QANCollection_PerfLists_HeaderFile
|
||||
|
||||
#include <QANCollection_ListOfPnt.hxx>
|
||||
#include <TColgp_SequenceOfPnt.hxx>
|
||||
|
||||
// ===================== Test perform of List type ==========================
|
||||
void CompList (const Standard_Integer theRep,
|
||||
const Standard_Integer theSize)
|
||||
{
|
||||
Standard_Integer i,j;
|
||||
|
||||
////////////////////////////////Perf_Meter aNAppe ("NCollection_List appending",0);
|
||||
////////////////////////////////Perf_Meter aTAppe ("TCollection_List appending",0);
|
||||
////////////////////////////////Perf_Meter aNOper ("NCollection_List operator=",0);
|
||||
////////////////////////////////Perf_Meter aTOper ("TCollection_List operator=",0);
|
||||
////////////////////////////////Perf_Meter aNClea ("NCollection_List clearing",0);
|
||||
////////////////////////////////Perf_Meter aTClea ("TCollection_List clearing",0);
|
||||
////////////////////////////////Perf_Meter aNAssi ("NCollection_List Assign",0);
|
||||
for (i=0; i<theRep; i++)
|
||||
{
|
||||
////////////////////////////////QANCollection_List a1, a2;
|
||||
QANCollection_ListPerf a1, a2;
|
||||
////////////////////////////////aNAppe.Start();
|
||||
PERF_START_METER("NCollection_List appending")
|
||||
for (j=1; j<=theSize; j++)
|
||||
{
|
||||
ItemType anItem;
|
||||
Random(anItem);
|
||||
a1.Append(anItem);
|
||||
}
|
||||
////////////////////////////////aNAppe.Stop();
|
||||
PERF_STOP_METER("NCollection_List appending")
|
||||
////////////////////////////////aNOper.Start();
|
||||
PERF_START_METER("NCollection_List operator=")
|
||||
a2 = a1;
|
||||
////////////////////////////////aNOper.Stop();
|
||||
PERF_STOP_METER("NCollection_List operator=")
|
||||
////////////////////////////////aNAssi.Start();
|
||||
PERF_START_METER("NCollection_List Assign")
|
||||
a2.Assign(a1);
|
||||
////////////////////////////////aNAssi.Stop();
|
||||
PERF_STOP_METER("NCollection_List Assign")
|
||||
////////////////////////////////aNClea.Start();
|
||||
PERF_START_METER("NCollection_List clearing")
|
||||
a2.Clear();
|
||||
////////////////////////////////aNClea.Stop();
|
||||
PERF_STOP_METER("NCollection_List clearing")
|
||||
}
|
||||
|
||||
for (i=0; i<theRep; i++)
|
||||
{
|
||||
QANCollection_ListOfPnt a1, a2;
|
||||
////////////////////////////////aTAppe.Start();
|
||||
PERF_START_METER("TCollection_List appending")
|
||||
for (j=1; j<=theSize; j++)
|
||||
{
|
||||
ItemType anItem;
|
||||
Random(anItem);
|
||||
a1.Append(anItem);
|
||||
}
|
||||
////////////////////////////////aTAppe.Stop();
|
||||
PERF_STOP_METER("TCollection_List appending")
|
||||
////////////////////////////////aTOper.Start();
|
||||
PERF_START_METER("TCollection_List operator=")
|
||||
a2 = a1;
|
||||
////////////////////////////////aTOper.Stop();
|
||||
PERF_STOP_METER("TCollection_List operator=")
|
||||
////////////////////////////////aTClea.Start();
|
||||
PERF_START_METER("TCollection_List clearing")
|
||||
a2.Clear();
|
||||
////////////////////////////////aTClea.Stop();
|
||||
PERF_STOP_METER("TCollection_List clearing")
|
||||
}
|
||||
PERF_PRINT_ALL
|
||||
}
|
||||
|
||||
|
||||
|
||||
// ===================== Test perform of Sequence type ==========================
|
||||
void CompSequence (const Standard_Integer theRep,
|
||||
const Standard_Integer theSize)
|
||||
{
|
||||
Standard_Integer i,j;
|
||||
|
||||
////////////////////////////////Perf_Meter aNAppe ("NCollection_Sequence appending",0);
|
||||
////////////////////////////////Perf_Meter aTAppe ("TCollection_Sequence appending",0);
|
||||
////////////////////////////////Perf_Meter aNFind ("NCollection_Sequence finding",0);
|
||||
////////////////////////////////Perf_Meter aTFind ("TCollection_Sequence finding",0);
|
||||
////////////////////////////////Perf_Meter aNOper ("NCollection_Sequence operator=",0);
|
||||
////////////////////////////////Perf_Meter aTOper ("TCollection_Sequence operator=",0);
|
||||
////////////////////////////////Perf_Meter aNClea ("NCollection_Sequence clearing",0);
|
||||
////////////////////////////////Perf_Meter aTClea ("TCollection_Sequence clearing",0);
|
||||
////////////////////////////////Perf_Meter aNAssi ("NCollection_Sequence Assign",0);
|
||||
for (i=0; i<theRep; i++)
|
||||
{
|
||||
////////////////////////////////QANCollection_Sequence a1, a2;
|
||||
QANCollection_SequencePerf a1, a2;
|
||||
////////////////////////////////aNAppe.Start();
|
||||
PERF_START_METER("NCollection_Sequence appending")
|
||||
for (j=1; j<=theSize; j++)
|
||||
{
|
||||
ItemType anItem;
|
||||
Random(anItem);
|
||||
a1.Append(anItem);
|
||||
}
|
||||
////////////////////////////////aNAppe.Stop();
|
||||
PERF_STOP_METER("NCollection_Sequence appending")
|
||||
////////////////////////////////aNFind.Start();
|
||||
PERF_START_METER("NCollection_Sequence finding")
|
||||
for (j=1; j<=theSize; j++)
|
||||
{
|
||||
Standard_Integer iIndex;
|
||||
Random(iIndex,theSize);
|
||||
a1.Value(iIndex+1);
|
||||
}
|
||||
////////////////////////////////aNFind.Stop();
|
||||
PERF_STOP_METER("NCollection_Sequence finding")
|
||||
////////////////////////////////aNOper.Start();
|
||||
PERF_START_METER("NCollection_Sequence operator=")
|
||||
a2 = a1;
|
||||
////////////////////////////////aNOper.Stop();
|
||||
PERF_STOP_METER("NCollection_Sequence operator=")
|
||||
////////////////////////////////aNAssi.Start();
|
||||
PERF_START_METER("NCollection_Sequence Assign")
|
||||
a2.Assign(a1);
|
||||
////////////////////////////////aNAssi.Stop();
|
||||
PERF_STOP_METER("NCollection_Sequence Assign")
|
||||
////////////////////////////////aNClea.Start();
|
||||
PERF_START_METER("NCollection_Sequence clearing")
|
||||
a2.Clear();
|
||||
////////////////////////////////aNClea.Stop();
|
||||
PERF_STOP_METER("NCollection_Sequence clearing")
|
||||
}
|
||||
|
||||
for (i=0; i<theRep; i++)
|
||||
{
|
||||
TColgp_SequenceOfPnt a1, a2;
|
||||
////////////////////////////////aTAppe.Start();
|
||||
PERF_START_METER("TCollection_Sequence appending")
|
||||
for (j=1; j<=theSize; j++)
|
||||
{
|
||||
ItemType anItem;
|
||||
Random(anItem);
|
||||
a1.Append(anItem);
|
||||
}
|
||||
////////////////////////////////aTAppe.Stop();
|
||||
PERF_STOP_METER("TCollection_Sequence appending")
|
||||
////////////////////////////////aTFind.Start();
|
||||
PERF_START_METER("TCollection_Sequence finding")
|
||||
for (j=1; j<=theSize; j++)
|
||||
{
|
||||
Standard_Integer iIndex;
|
||||
Random(iIndex,theSize);
|
||||
a1.Value(iIndex+1);
|
||||
}
|
||||
////////////////////////////////aTFind.Stop();
|
||||
PERF_STOP_METER("TCollection_Sequence finding")
|
||||
////////////////////////////////aTOper.Start();
|
||||
PERF_START_METER("TCollection_Sequence operator=")
|
||||
a2 = a1;
|
||||
////////////////////////////////aTOper.Stop();
|
||||
PERF_STOP_METER("TCollection_Sequence operator=")
|
||||
////////////////////////////////aTClea.Start();
|
||||
PERF_START_METER("TCollection_Sequence clearing")
|
||||
a2.Clear();
|
||||
////////////////////////////////aTClea.Stop();
|
||||
PERF_STOP_METER("TCollection_Sequence clearing")
|
||||
}
|
||||
PERF_PRINT_ALL
|
||||
}
|
||||
|
||||
#endif
|
||||
@ -1,516 +0,0 @@
|
||||
// Created on: 2002-04-30
|
||||
// Created by: Alexander KARTOMIN (akm)
|
||||
// Copyright (c) 2002-2014 OPEN CASCADE SAS
|
||||
//
|
||||
// This file is part of Open CASCADE Technology software library.
|
||||
//
|
||||
// This library is free software; you can redistribute it and/or modify it under
|
||||
// the terms of the GNU Lesser General Public License version 2.1 as published
|
||||
// by the Free Software Foundation, with special exception defined in the file
|
||||
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
|
||||
// distribution for complete text of the license and disclaimer of any warranty.
|
||||
//
|
||||
// Alternatively, this file may be used under the terms of Open CASCADE
|
||||
// commercial license or contractual agreement.
|
||||
|
||||
#ifndef QANCollection_PerfMaps_HeaderFile
|
||||
#define QANCollection_PerfMaps_HeaderFile
|
||||
|
||||
#include <TColStd_MapOfReal.hxx>
|
||||
#include <TColStd_IndexedMapOfReal.hxx>
|
||||
#include <QANCollection_DataMapOfRealPnt.hxx>
|
||||
#include <QANCollection_DoubleMapOfRealInteger.hxx>
|
||||
#include <QANCollection_IndexedDataMapOfRealPnt.hxx>
|
||||
|
||||
// ===================== Test perform of Map type ==========================
|
||||
void CompMap (const Standard_Integer theRep,
|
||||
const Standard_Integer theSize)
|
||||
{
|
||||
Standard_Integer i,j;
|
||||
|
||||
////////////////////////////////Perf_Meter aNBind ("NCollection_Map adding",0);
|
||||
////////////////////////////////Perf_Meter aTBind ("TCollection_Map adding",0);
|
||||
////////////////////////////////Perf_Meter aNOper ("NCollection_Map operator=",0);
|
||||
////////////////////////////////Perf_Meter aTOper ("TCollection_Map operator=",0);
|
||||
////////////////////////////////Perf_Meter aNFind ("NCollection_Map finding",0);
|
||||
////////////////////////////////Perf_Meter aTFind ("TCollection_Map finding",0);
|
||||
////////////////////////////////Perf_Meter aNClea ("NCollection_Map clearing",0);
|
||||
////////////////////////////////Perf_Meter aTClea ("TCollection_Map clearing",0);
|
||||
////////////////////////////////Perf_Meter aNAssi ("NCollection_Map Assign",0);
|
||||
for (i=0; i<theRep; i++)
|
||||
{
|
||||
////////////////////////////////QANCollection_Map a1, a2;
|
||||
QANCollection_MapPerf a1, a2;
|
||||
////////////////////////////////aNBind.Start();
|
||||
PERF_START_METER("NCollection_Map adding")
|
||||
for (j=1; j<=theSize; j++)
|
||||
{
|
||||
Key1Type aKey1;
|
||||
Random(aKey1);
|
||||
a1.Add(aKey1);
|
||||
}
|
||||
////////////////////////////////aNBind.Stop();
|
||||
PERF_STOP_METER("NCollection_Map adding")
|
||||
////////////////////////////////aNFind.Start();
|
||||
PERF_START_METER("NCollection_Map finding")
|
||||
for (j=1; j<=theSize; j++)
|
||||
{
|
||||
Key1Type aKey1;
|
||||
Random(aKey1);
|
||||
a1.Contains(aKey1);
|
||||
}
|
||||
////////////////////////////////aNFind.Stop();
|
||||
PERF_STOP_METER("NCollection_Map finding")
|
||||
////////////////////////////////aNOper.Start();
|
||||
PERF_START_METER("NCollection_Map operator=")
|
||||
a2 = a1;
|
||||
////////////////////////////////aNOper.Stop();
|
||||
PERF_STOP_METER("NCollection_Map operator=")
|
||||
////////////////////////////////aNAssi.Start();
|
||||
PERF_START_METER("NCollection_Map Assign")
|
||||
a2.Assign(a1);
|
||||
////////////////////////////////aNAssi.Stop();
|
||||
PERF_STOP_METER("NCollection_Map Assign")
|
||||
////////////////////////////////aNClea.Start();
|
||||
PERF_START_METER("NCollection_Map clearing")
|
||||
a2.Clear();
|
||||
////////////////////////////////aNClea.Stop();
|
||||
PERF_STOP_METER("NCollection_Map clearing")
|
||||
}
|
||||
|
||||
for (i=0; i<theRep; i++)
|
||||
{
|
||||
TColStd_MapOfReal a1, a2;
|
||||
////////////////////////////////aTBind.Start();
|
||||
PERF_START_METER("TCollection_Map adding")
|
||||
for (j=1; j<=theSize; j++)
|
||||
{
|
||||
Key1Type aKey1;
|
||||
Random(aKey1);
|
||||
a1.Add(aKey1);
|
||||
}
|
||||
////////////////////////////////aTBind.Stop();
|
||||
PERF_STOP_METER("TCollection_Map adding")
|
||||
////////////////////////////////aTFind.Start();
|
||||
PERF_START_METER("TCollection_Map finding")
|
||||
for (j=1; j<=theSize; j++)
|
||||
{
|
||||
Key1Type aKey1;
|
||||
Random(aKey1);
|
||||
a1.Contains(aKey1);
|
||||
}
|
||||
////////////////////////////////aTFind.Stop();
|
||||
PERF_STOP_METER("TCollection_Map finding")
|
||||
////////////////////////////////aTOper.Start();
|
||||
PERF_START_METER("TCollection_Map operator=")
|
||||
a2 = a1;
|
||||
////////////////////////////////aTOper.Stop();
|
||||
PERF_STOP_METER("TCollection_Map operator=")
|
||||
////////////////////////////////aTClea.Start();
|
||||
PERF_START_METER("TCollection_Map clearing")
|
||||
a2.Clear();
|
||||
////////////////////////////////aTClea.Stop();
|
||||
PERF_STOP_METER("TCollection_Map clearing")
|
||||
}
|
||||
PERF_PRINT_ALL
|
||||
}
|
||||
|
||||
// ===================== Test perform of DataMap type ==========================
|
||||
void CompDataMap (const Standard_Integer theRep,
|
||||
const Standard_Integer theSize)
|
||||
{
|
||||
Standard_Integer i,j;
|
||||
|
||||
////////////////////////////////Perf_Meter aNBind ("NCollection_DataMap binding",0);
|
||||
////////////////////////////////Perf_Meter aTBind ("TCollection_DataMap binding",0);
|
||||
////////////////////////////////Perf_Meter aNFind ("NCollection_DataMap finding",0);
|
||||
////////////////////////////////Perf_Meter aTFind ("TCollection_DataMap finding",0);
|
||||
////////////////////////////////Perf_Meter aNOper ("NCollection_DataMap operator=",0);
|
||||
////////////////////////////////Perf_Meter aTOper ("TCollection_DataMap operator=",0);
|
||||
////////////////////////////////Perf_Meter aNClea ("NCollection_DataMap clearing",0);
|
||||
////////////////////////////////Perf_Meter aTClea ("TCollection_DataMap clearing",0);
|
||||
//////////////////////////////////Perf_Meter aNAssi ("NCollection_DataMap Assign",0);
|
||||
for (i=0; i<theRep; i++)
|
||||
{
|
||||
////////////////////////////////QANCollection_DataMap a1, a2;
|
||||
QANCollection_DataMapPerf a1, a2;
|
||||
////////////////////////////////aNBind.Start();
|
||||
PERF_START_METER("NCollection_DataMap binding")
|
||||
for (j=1; j<=theSize; j++)
|
||||
{
|
||||
Key1Type aKey1;
|
||||
ItemType anItem;
|
||||
Random(aKey1);
|
||||
Random(anItem);
|
||||
a1.Bind(aKey1,anItem);
|
||||
}
|
||||
////////////////////////////////aNBind.Stop();
|
||||
PERF_STOP_METER("NCollection_DataMap binding")
|
||||
////////////////////////////////aNFind.Start();
|
||||
PERF_START_METER("NCollection_DataMap finding")
|
||||
for (j=1; j<=theSize; j++)
|
||||
{
|
||||
Key1Type aKey1;
|
||||
Random(aKey1);
|
||||
a1.IsBound(aKey1);
|
||||
}
|
||||
////////////////////////////////aNFind.Stop();
|
||||
PERF_STOP_METER("NCollection_DataMap finding")
|
||||
////////////////////////////////aNOper.Start();
|
||||
PERF_START_METER("NCollection_DataMap operator=")
|
||||
a2 = a1;
|
||||
////////////////////////////////aNOper.Stop();
|
||||
PERF_STOP_METER("NCollection_DataMap operator=")
|
||||
//aNAssi.Start();
|
||||
//a2.Assign(a1);
|
||||
//aNAssi.Stop();
|
||||
////////////////////////////////aNClea.Start();
|
||||
PERF_START_METER("NCollection_DataMap clearing")
|
||||
a2.Clear();
|
||||
////////////////////////////////aNClea.Stop();
|
||||
PERF_STOP_METER("NCollection_DataMap clearing")
|
||||
}
|
||||
|
||||
for (i=0; i<theRep; i++)
|
||||
{
|
||||
QANCollection_DataMapOfRealPnt a1, a2;
|
||||
////////////////////////////////aTBind.Start();
|
||||
PERF_START_METER("TCollection_DataMap binding")
|
||||
for (j=1; j<=theSize; j++)
|
||||
{
|
||||
Key1Type aKey1;
|
||||
ItemType anItem;
|
||||
Random(aKey1);
|
||||
Random(anItem);
|
||||
a1.Bind(aKey1,anItem);
|
||||
}
|
||||
////////////////////////////////aTBind.Stop();
|
||||
PERF_STOP_METER("TCollection_DataMap binding")
|
||||
////////////////////////////////aTFind.Start();
|
||||
PERF_START_METER("TCollection_DataMap finding")
|
||||
for (j=1; j<=theSize; j++)
|
||||
{
|
||||
Key1Type aKey1;
|
||||
Random(aKey1);
|
||||
a1.IsBound(aKey1);
|
||||
}
|
||||
////////////////////////////////aTFind.Stop();
|
||||
PERF_STOP_METER("TCollection_DataMap finding")
|
||||
////////////////////////////////aTOper.Start();
|
||||
PERF_START_METER("TCollection_DataMap operator=")
|
||||
a2 = a1;
|
||||
////////////////////////////////aTOper.Stop();
|
||||
PERF_STOP_METER("TCollection_DataMap operator=")
|
||||
////////////////////////////////aTClea.Start();
|
||||
PERF_START_METER("TCollection_DataMap clearing")
|
||||
a2.Clear();
|
||||
////////////////////////////////aTClea.Stop();
|
||||
PERF_STOP_METER("TCollection_DataMap clearing")
|
||||
}
|
||||
PERF_PRINT_ALL
|
||||
}
|
||||
|
||||
// ===================== Test perform of DoubleMap type ==========================
|
||||
void CompDoubleMap (const Standard_Integer theRep,
|
||||
const Standard_Integer theSize)
|
||||
{
|
||||
Standard_Integer i,j;
|
||||
Standard_Integer iFail1=0, iFail2=0;
|
||||
|
||||
////////////////////////////////Perf_Meter aNBind ("NCollection_DoubleMap binding",0);
|
||||
////////////////////////////////Perf_Meter aTBind ("TCollection_DoubleMap binding",0);
|
||||
////////////////////////////////Perf_Meter aNFind ("NCollection_DoubleMap finding",0);
|
||||
////////////////////////////////Perf_Meter aTFind ("TCollection_DoubleMap finding",0);
|
||||
////////////////////////////////Perf_Meter aNOper ("NCollection_DoubleMap operator=",0);
|
||||
////////////////////////////////Perf_Meter aTOper ("TCollection_DoubleMap operator=",0);
|
||||
////////////////////////////////Perf_Meter aNClea ("NCollection_DoubleMap clearing",0);
|
||||
////////////////////////////////Perf_Meter aTClea ("TCollection_DoubleMap clearing",0);
|
||||
//////////////////////////////////Perf_Meter aNAssi ("NCollection_DoubleMap Assign",0);
|
||||
for (i=0; i<theRep; i++)
|
||||
{
|
||||
////////////////////////////////QANCollection_DoubleMap a1, a2;
|
||||
QANCollection_DoubleMapPerf a1, a2;
|
||||
////////////////////////////////aNBind.Start();
|
||||
PERF_START_METER("NCollection_DoubleMap binding")
|
||||
for (j=1; j<=theSize; j++)
|
||||
{
|
||||
Key1Type aKey1;
|
||||
Key2Type aKey2;
|
||||
do {
|
||||
Random(aKey1);
|
||||
Random(aKey2);
|
||||
iFail1++;
|
||||
}
|
||||
while (a1.IsBound1(aKey1) || a1.IsBound2(aKey2));
|
||||
iFail1--;
|
||||
a1.Bind(aKey1,aKey2);
|
||||
}
|
||||
////////////////////////////////aNBind.Stop();
|
||||
PERF_STOP_METER("NCollection_DoubleMap binding")
|
||||
////////////////////////////////aNFind.Start();
|
||||
PERF_START_METER("NCollection_DoubleMap finding")
|
||||
for (j=1; j<=theSize; j++)
|
||||
{
|
||||
Key1Type aKey1;
|
||||
Key2Type aKey2;
|
||||
Random(aKey1);
|
||||
Random(aKey2);
|
||||
a1.AreBound(aKey1,aKey2);
|
||||
}
|
||||
////////////////////////////////aNFind.Stop();
|
||||
PERF_STOP_METER("NCollection_DoubleMap finding")
|
||||
////////////////////////////////aNOper.Start();
|
||||
PERF_START_METER("NCollection_DoubleMap operator=")
|
||||
a2 = a1;
|
||||
////////////////////////////////aNOper.Stop();
|
||||
PERF_STOP_METER("NCollection_DoubleMap operator=")
|
||||
//aNAssi.Start();
|
||||
//a2.Assign(a1);
|
||||
//aNAssi.Stop();
|
||||
////////////////////////////////aNClea.Start();
|
||||
PERF_START_METER("NCollection_DoubleMap clearing")
|
||||
a2.Clear();
|
||||
////////////////////////////////aNClea.Stop();
|
||||
PERF_STOP_METER("NCollection_DoubleMap clearing")
|
||||
}
|
||||
|
||||
for (i=0; i<theRep; i++)
|
||||
{
|
||||
QANCollection_DoubleMapOfRealInteger a1, a2;
|
||||
////////////////////////////////aTBind.Start();
|
||||
PERF_START_METER("TCollection_DoubleMap binding")
|
||||
for (j=1; j<=theSize; j++)
|
||||
{
|
||||
Key1Type aKey1;
|
||||
Key2Type aKey2;
|
||||
do {
|
||||
Random(aKey1);
|
||||
Random(aKey2);
|
||||
iFail2++;
|
||||
}
|
||||
while (a1.IsBound1(aKey1) || a1.IsBound2(aKey2));
|
||||
iFail2--;
|
||||
a1.Bind(aKey1,aKey2);
|
||||
}
|
||||
////////////////////////////////aTBind.Stop();
|
||||
PERF_STOP_METER("TCollection_DoubleMap binding")
|
||||
////////////////////////////////aTFind.Start();
|
||||
PERF_START_METER("TCollection_DoubleMap finding")
|
||||
for (j=1; j<=theSize; j++)
|
||||
{
|
||||
Key1Type aKey1;
|
||||
Key2Type aKey2;
|
||||
Random(aKey1);
|
||||
Random(aKey2);
|
||||
a1.AreBound(aKey1,aKey2);
|
||||
}
|
||||
////////////////////////////////aTFind.Stop();
|
||||
PERF_STOP_METER("TCollection_DoubleMap finding")
|
||||
////////////////////////////////aTOper.Start();
|
||||
PERF_START_METER("TCollection_DoubleMap operator=")
|
||||
a2 = a1;
|
||||
////////////////////////////////aTOper.Stop();
|
||||
PERF_STOP_METER("TCollection_DoubleMap operator=")
|
||||
////////////////////////////////aTClea.Start();
|
||||
PERF_START_METER("TCollection_DoubleMap clearing")
|
||||
a2.Clear();
|
||||
////////////////////////////////aTClea.Stop();
|
||||
PERF_STOP_METER("TCollection_DoubleMap clearing")
|
||||
}
|
||||
PERF_PRINT_ALL
|
||||
if (iFail1 || iFail2)
|
||||
cout << "Warning : N map failed " << iFail1 << " times, T map - " <<
|
||||
iFail2 << endl;
|
||||
}
|
||||
|
||||
// ===================== Test perform of IndexedMap type ==========================
|
||||
void CompIndexedMap (const Standard_Integer theRep,
|
||||
const Standard_Integer theSize)
|
||||
{
|
||||
Standard_Integer i,j;
|
||||
|
||||
////////////////////////////////Perf_Meter aNBind ("NCollection_IndexedMap adding",0);
|
||||
////////////////////////////////Perf_Meter aTBind ("TCollection_IndexedMap adding",0);
|
||||
////////////////////////////////Perf_Meter aNOper ("NCollection_IndexedMap operator=",0);
|
||||
////////////////////////////////Perf_Meter aTOper ("TCollection_IndexedMap operator=",0);
|
||||
////////////////////////////////Perf_Meter aNFind ("NCollection_IndexedMap finding",0);
|
||||
////////////////////////////////Perf_Meter aTFind ("TCollection_IndexedMap finding",0);
|
||||
////////////////////////////////Perf_Meter aNClea ("NCollection_IndexedMap clearing",0);
|
||||
////////////////////////////////Perf_Meter aTClea ("TCollection_IndexedMap clearing",0);
|
||||
////////////////////////////////Perf_Meter aNAssi ("NCollection_IndexedMap Assign",0);
|
||||
|
||||
for (i=0; i<theRep; i++)
|
||||
{
|
||||
////////////////////////////////QANCollection_IndexedMap a1, a2;
|
||||
QANCollection_IndexedMapPerf a1, a2;
|
||||
////////////////////////////////aNBind.Start();
|
||||
PERF_START_METER("NCollection_IndexedMap adding")
|
||||
for (j=1; j<=theSize; j++)
|
||||
{
|
||||
Key1Type aKey1;
|
||||
Random(aKey1);
|
||||
a1.Add(aKey1);
|
||||
}
|
||||
////////////////////////////////aNBind.Stop();
|
||||
PERF_STOP_METER("NCollection_IndexedMap adding")
|
||||
////////////////////////////////aNFind.Start();
|
||||
PERF_START_METER("NCollection_IndexedMap finding")
|
||||
for (j=1; j<=theSize; j++)
|
||||
{
|
||||
Key1Type aKey1;
|
||||
Random(aKey1);
|
||||
a1.Contains(aKey1);
|
||||
}
|
||||
////////////////////////////////aNFind.Stop();
|
||||
PERF_STOP_METER("NCollection_IndexedMap finding")
|
||||
////////////////////////////////aNOper.Start();
|
||||
PERF_START_METER("NCollection_IndexedMap operator=")
|
||||
a2 = a1;
|
||||
////////////////////////////////aNOper.Stop();
|
||||
PERF_STOP_METER("NCollection_IndexedMap operator=")
|
||||
////////////////////////////////aNAssi.Start();
|
||||
PERF_START_METER("NCollection_IndexedMap Assign")
|
||||
a2.Assign(a1);
|
||||
////////////////////////////////aNAssi.Stop();
|
||||
PERF_STOP_METER("NCollection_IndexedMap Assign")
|
||||
////////////////////////////////aNClea.Start();
|
||||
PERF_START_METER("NCollection_IndexedMap clearing")
|
||||
a2.Clear();
|
||||
////////////////////////////////aNClea.Stop();
|
||||
PERF_STOP_METER("NCollection_IndexedMap clearing")
|
||||
}
|
||||
|
||||
for (i=0; i<theRep; i++)
|
||||
{
|
||||
TColStd_IndexedMapOfReal a1, a2;
|
||||
////////////////////////////////aTBind.Start();
|
||||
PERF_START_METER("TCollection_IndexedMap adding")
|
||||
for (j=1; j<=theSize; j++)
|
||||
{
|
||||
Key1Type aKey1;
|
||||
Random(aKey1);
|
||||
a1.Add(aKey1);
|
||||
}
|
||||
////////////////////////////////aTBind.Stop();
|
||||
PERF_STOP_METER("TCollection_IndexedMap adding")
|
||||
////////////////////////////////aTFind.Start();
|
||||
PERF_START_METER("TCollection_IndexedMap finding")
|
||||
for (j=1; j<=theSize; j++)
|
||||
{
|
||||
Key1Type aKey1;
|
||||
Random(aKey1);
|
||||
a1.Contains(aKey1);
|
||||
}
|
||||
////////////////////////////////aTFind.Stop();
|
||||
PERF_STOP_METER("TCollection_IndexedMap finding")
|
||||
////////////////////////////////aTOper.Start();
|
||||
PERF_START_METER("TCollection_IndexedMap operator=")
|
||||
a2 = a1;
|
||||
////////////////////////////////aTOper.Stop();
|
||||
PERF_STOP_METER("TCollection_IndexedMap operator=")
|
||||
////////////////////////////////aTClea.Start();
|
||||
PERF_START_METER("TCollection_IndexedMap clearing")
|
||||
a2.Clear();
|
||||
////////////////////////////////aTClea.Stop();
|
||||
PERF_STOP_METER("TCollection_IndexedMap clearing")
|
||||
}
|
||||
PERF_PRINT_ALL
|
||||
}
|
||||
|
||||
// ===================== Test perform of IndexedDataMap type ==========================
|
||||
void CompIndexedDataMap (const Standard_Integer theRep,
|
||||
const Standard_Integer theSize)
|
||||
{
|
||||
Standard_Integer i,j;
|
||||
|
||||
////////////////////////////////Perf_Meter aNBind ("NCollection_IndexedDataMap binding",0);
|
||||
////////////////////////////////Perf_Meter aTBind ("TCollection_IndexedDataMap binding",0);
|
||||
////////////////////////////////Perf_Meter aNFind ("NCollection_IndexedDataMap finding",0);
|
||||
////////////////////////////////Perf_Meter aTFind ("TCollection_IndexedDataMap finding",0);
|
||||
////////////////////////////////Perf_Meter aNOper ("NCollection_IndexedDataMap operator=",0);
|
||||
////////////////////////////////Perf_Meter aTOper ("TCollection_IndexedDataMap operator=",0);
|
||||
////////////////////////////////Perf_Meter aNClea ("NCollection_IndexedDataMap clearing",0);
|
||||
////////////////////////////////Perf_Meter aTClea ("TCollection_IndexedDataMap clearing",0);
|
||||
//////////////////////////////////Perf_Meter aNAssi ("NCollection_IndexedDataMap Assign",0);
|
||||
|
||||
for (i=0; i<theRep; i++)
|
||||
{
|
||||
////////////////////////////////QANCollection_IDMap a1, a2;
|
||||
QANCollection_IDMapPerf a1, a2;
|
||||
////////////////////////////////aNBind.Start();
|
||||
PERF_START_METER("NCollection_IndexedDataMap binding")
|
||||
for (j=1; j<=theSize; j++)
|
||||
{
|
||||
Key1Type aKey1;
|
||||
ItemType anItem;
|
||||
Random(aKey1);
|
||||
Random(anItem);
|
||||
a1.Add(aKey1,anItem);
|
||||
}
|
||||
////////////////////////////////aNBind.Stop();
|
||||
PERF_STOP_METER("NCollection_IndexedDataMap binding")
|
||||
////////////////////////////////aNFind.Start();
|
||||
PERF_START_METER("NCollection_IndexedDataMap finding")
|
||||
for (j=1; j<=theSize; j++)
|
||||
{
|
||||
Key1Type aKey1;
|
||||
Random(aKey1);
|
||||
a1.Contains(aKey1);
|
||||
}
|
||||
////////////////////////////////aNFind.Stop();
|
||||
PERF_STOP_METER("NCollection_IndexedDataMap finding")
|
||||
////////////////////////////////aNOper.Start();
|
||||
PERF_START_METER("NCollection_IndexedDataMap operator=")
|
||||
a2 = a1;
|
||||
////////////////////////////////aNOper.Stop();
|
||||
PERF_STOP_METER("NCollection_IndexedDataMap operator=")
|
||||
//aNAssi.Start();
|
||||
//a2.Assign(a1);
|
||||
//aNAssi.Stop();
|
||||
////////////////////////////////aNClea.Start();
|
||||
PERF_START_METER("NCollection_IndexedDataMap clearing")
|
||||
a2.Clear();
|
||||
////////////////////////////////aNClea.Stop();
|
||||
PERF_STOP_METER("NCollection_IndexedDataMap clearing")
|
||||
}
|
||||
|
||||
for (i=0; i<theRep; i++)
|
||||
{
|
||||
QANCollection_IndexedDataMapOfRealPnt a1, a2;
|
||||
////////////////////////////////aTBind.Start();
|
||||
PERF_START_METER("TCollection_IndexedDataMap binding")
|
||||
for (j=1; j<=theSize; j++)
|
||||
{
|
||||
Key1Type aKey1;
|
||||
ItemType anItem;
|
||||
Random(aKey1);
|
||||
Random(anItem);
|
||||
a1.Add(aKey1,anItem);
|
||||
}
|
||||
////////////////////////////////aTBind.Stop();
|
||||
PERF_STOP_METER("TCollection_IndexedDataMap binding")
|
||||
////////////////////////////////aTFind.Start();
|
||||
PERF_START_METER("TCollection_IndexedDataMap finding")
|
||||
for (j=1; j<=theSize; j++)
|
||||
{
|
||||
Key1Type aKey1;
|
||||
Random(aKey1);
|
||||
a1.Contains(aKey1);
|
||||
}
|
||||
////////////////////////////////aTFind.Stop();
|
||||
PERF_STOP_METER("TCollection_IndexedDataMap finding")
|
||||
////////////////////////////////aTOper.Start();
|
||||
PERF_START_METER("TCollection_IndexedDataMap operator=")
|
||||
a2 = a1;
|
||||
////////////////////////////////aTOper.Stop();
|
||||
PERF_STOP_METER("TCollection_IndexedDataMap operator=")
|
||||
////////////////////////////////aTClea.Start();
|
||||
PERF_START_METER("TCollection_IndexedDataMap clearing")
|
||||
a2.Clear();
|
||||
////////////////////////////////aTClea.Stop();
|
||||
PERF_STOP_METER("TCollection_IndexedDataMap clearing")
|
||||
}
|
||||
PERF_PRINT_ALL
|
||||
}
|
||||
|
||||
#endif
|
||||
@ -1,82 +0,0 @@
|
||||
// Created on: 2002-05-15
|
||||
// Created by: Alexander KARTOMIN (akm)
|
||||
// Copyright (c) 2002-2014 OPEN CASCADE SAS
|
||||
//
|
||||
// This file is part of Open CASCADE Technology software library.
|
||||
//
|
||||
// This library is free software; you can redistribute it and/or modify it under
|
||||
// the terms of the GNU Lesser General Public License version 2.1 as published
|
||||
// by the Free Software Foundation, with special exception defined in the file
|
||||
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
|
||||
// distribution for complete text of the license and disclaimer of any warranty.
|
||||
//
|
||||
// Alternatively, this file may be used under the terms of Open CASCADE
|
||||
// commercial license or contractual agreement.
|
||||
|
||||
#ifndef QANCollection_PerfSparseArray_HeaderFile
|
||||
#define QANCollection_PerfSparseArray_HeaderFile
|
||||
|
||||
#define PERF_ENABLE_METERS
|
||||
#include <OSD_PerfMeter.hxx>
|
||||
////////////////////////////////#include <Perf_Meter.hxx>
|
||||
#include <NCollection_SparseArray.hxx>
|
||||
#include <NCollection_SparseArrayBase.hxx>
|
||||
|
||||
// ===================== Test perform of SparseArray type ==========================
|
||||
void CompSparseArray (const Standard_Integer theRep, const Standard_Integer theSize)
|
||||
{
|
||||
Standard_Integer i,j;
|
||||
for (i=0; i<theRep; i++)
|
||||
{
|
||||
PERF_START_METER("NCollection_SparseArray creation")
|
||||
|
||||
NCollection_SparseArray<Standard_Integer> a1(theSize),a2(theSize);
|
||||
|
||||
PERF_STOP_METER("NCollection_SparseArray creation")
|
||||
|
||||
PERF_START_METER("NCollection_SparseArray filling")
|
||||
for( j=0;j<theSize;j++ )
|
||||
{
|
||||
Standard_Integer iIndex;
|
||||
Random(iIndex,theSize);
|
||||
a1.SetValue(j,iIndex+1);
|
||||
}
|
||||
|
||||
PERF_STOP_METER("NCollection_SparseArray filling")
|
||||
|
||||
PERF_START_METER("NCollection_SparseArray size")
|
||||
Standard_Size sizeSparseArray=a1.Size();
|
||||
(void)sizeSparseArray; // avoid compiler warning on unused variable
|
||||
PERF_STOP_METER("NCollection_SparseArray size")
|
||||
|
||||
PERF_START_METER("NCollection_Array1 Assign")
|
||||
a2.Assign(a1);
|
||||
PERF_STOP_METER("NCollection_Array1 Assign")
|
||||
PERF_START_METER("NCollection_SparseArray HasValue")
|
||||
for (j=0; j<theSize; j++)
|
||||
{
|
||||
Standard_Integer iIndex;
|
||||
Random(iIndex,theSize);
|
||||
a2.HasValue(iIndex+1);
|
||||
}
|
||||
PERF_STOP_METER("NCollection_SparseArray HasValue")
|
||||
PERF_START_METER("NCollection_SparseArray UnsetValue")
|
||||
for (j=0; j<theSize; j++)
|
||||
{
|
||||
Standard_Integer iIndex;
|
||||
Random(iIndex,theSize);
|
||||
a1.UnsetValue(iIndex+1);
|
||||
}
|
||||
PERF_STOP_METER("NCollection_SparseArray UnsetValue")
|
||||
|
||||
PERF_START_METER("NCollection_SparseArray Clear")
|
||||
a1.Clear();
|
||||
a2.Clear();
|
||||
PERF_STOP_METER("NCollection_SparseArray Clear")
|
||||
|
||||
}
|
||||
|
||||
PERF_PRINT_ALL
|
||||
}
|
||||
|
||||
#endif
|
||||
@ -1,34 +0,0 @@
|
||||
// Created on: 2002-05-15
|
||||
// Created by: Alexander KARTOMIN (akm)
|
||||
// Copyright (c) 2002-2014 OPEN CASCADE SAS
|
||||
//
|
||||
// This file is part of Open CASCADE Technology software library.
|
||||
//
|
||||
// This library is free software; you can redistribute it and/or modify it under
|
||||
// the terms of the GNU Lesser General Public License version 2.1 as published
|
||||
// by the Free Software Foundation, with special exception defined in the file
|
||||
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
|
||||
// distribution for complete text of the license and disclaimer of any warranty.
|
||||
//
|
||||
// Alternatively, this file may be used under the terms of Open CASCADE
|
||||
// commercial license or contractual agreement.
|
||||
|
||||
// Purpose: To test the performance of NCollection classes
|
||||
|
||||
#ifndef QANCollection_PerfTest_HeaderFile
|
||||
#define QANCollection_PerfTest_HeaderFile
|
||||
|
||||
#include <gp_Pnt.hxx>
|
||||
#include <QANCollection_Common3.hxx>
|
||||
|
||||
// ===================== Test methods for each type ===========================
|
||||
// TCollection classes compared are the containers with
|
||||
// ValueType - gp_Pnt
|
||||
// Key1Type - Standard_Real
|
||||
// Key2Type - Standard_Integer
|
||||
|
||||
#include <QANCollection_PerfArrays.hxx>
|
||||
#include <QANCollection_PerfLists.hxx>
|
||||
#include <QANCollection_PerfMaps.hxx>
|
||||
|
||||
#endif
|
||||
@ -21,35 +21,118 @@
|
||||
#include <TColgp_Array1OfPnt.hxx>
|
||||
#include <TColgp_SequenceOfPnt.hxx>
|
||||
|
||||
#define USE_MACROS
|
||||
#ifdef USE_MACROS
|
||||
#include <NCollection_DefineArray1.hxx>
|
||||
#include <NCollection_DefineSequence.hxx>
|
||||
DEFINE_BASECOLLECTION (MyBaseCollPnt, gp_Pnt)
|
||||
DEFINE_ARRAY1 (MyArray1, MyBaseCollPnt, gp_Pnt)
|
||||
DEFINE_SEQUENCE (MySequence, MyBaseCollPnt, gp_Pnt)
|
||||
#else
|
||||
#include <NCollection_Sequence.hxx>
|
||||
#include <NCollection_Array1.hxx>
|
||||
#include <NCollection_IncAllocator.hxx>
|
||||
|
||||
typedef NCollection_Array1<gp_Pnt> MyArray1;
|
||||
typedef NCollection_Sequence<gp_Pnt> MySequence;
|
||||
typedef NCollection_BaseCollection<gp_Pnt> MyBaseCollPnt;
|
||||
#endif
|
||||
void checkArray (const Standard_Boolean);
|
||||
void checkSequence (const Standard_Boolean, const Standard_Boolean);
|
||||
void createArray (TColgp_Array1OfPnt&);
|
||||
void assignArray (TColgp_Array1OfPnt&, const TColgp_Array1OfPnt&);
|
||||
void createSequence (TColgp_SequenceOfPnt&);
|
||||
void assignSequence (TColgp_SequenceOfPnt&, const TColgp_SequenceOfPnt&);
|
||||
|
||||
void createArray (MyArray1&);
|
||||
void assignArray (MyArray1&, const MyArray1&);
|
||||
void createSequence (MySequence&);
|
||||
void assignSequence (MySequence&, const MySequence&);
|
||||
void assignCollection (MyBaseCollPnt&, const MyBaseCollPnt&, const char *);
|
||||
void printAllMeters ();
|
||||
const Standard_Integer REPEAT = 100;
|
||||
|
||||
void checkArray (const Standard_Boolean isNewColl)
|
||||
void printAllMeters ()
|
||||
{
|
||||
PERF_PRINT_ALL
|
||||
}
|
||||
|
||||
static void createArray (TColgp_Array1OfPnt& anArrPnt)
|
||||
{
|
||||
OSD_PerfMeter aPerfMeter("Create array");
|
||||
|
||||
for (Standard_Integer j = 0; j < 2*REPEAT; j++) {
|
||||
PERF_START_METER("Create array")
|
||||
for (Standard_Integer i = anArrPnt.Lower(); i <= anArrPnt.Upper(); i++)
|
||||
anArrPnt(i).SetCoord ((double)i, (double)(i+1), (double)(i+2));
|
||||
PERF_STOP_METER("Create array")
|
||||
}
|
||||
}
|
||||
|
||||
static void createSequence (TColgp_SequenceOfPnt& aSeq)
|
||||
{
|
||||
for (Standard_Integer j = 0; j < REPEAT; j++) {
|
||||
PERF_START_METER("Clear sequence")
|
||||
aSeq.Clear();
|
||||
PERF_STOP_METER("Clear sequence")
|
||||
PERF_START_METER("Create sequence")
|
||||
for (Standard_Integer i = 0; i < 100000; i++)
|
||||
aSeq.Append (gp_Pnt((double)i, (double)(i+1), (double)(i+2)));
|
||||
PERF_STOP_METER("Create sequence")
|
||||
}
|
||||
}
|
||||
|
||||
static void createSequence (MySequence& aSeq)
|
||||
{
|
||||
for (Standard_Integer j = 0; j < REPEAT; j++) {
|
||||
PERF_START_METER("Clear sequence")
|
||||
aSeq.Clear();
|
||||
PERF_STOP_METER("Clear sequence")
|
||||
PERF_START_METER("Create sequence")
|
||||
for (Standard_Integer i = 0; i < 100000; i++)
|
||||
aSeq.Append (gp_Pnt((double)i, (double)(i+1), (double)(i+2)));
|
||||
PERF_STOP_METER("Create sequence")
|
||||
}
|
||||
}
|
||||
|
||||
static void assignSequence (TColgp_SequenceOfPnt& aDest,
|
||||
const TColgp_SequenceOfPnt& aSrc)
|
||||
{
|
||||
for (Standard_Integer i = 0; i < REPEAT; i++) {
|
||||
PERF_START_METER("Assign sequence to sequence")
|
||||
aDest = aSrc;
|
||||
PERF_STOP_METER("Assign sequence to sequence")
|
||||
}
|
||||
}
|
||||
|
||||
static void assignSequence (MySequence& aDest, const MySequence& aSrc)
|
||||
{
|
||||
for (Standard_Integer i = 0; i < REPEAT; i++) {
|
||||
PERF_START_METER("Assign sequence to sequence")
|
||||
aDest = aSrc;
|
||||
PERF_STOP_METER("Assign sequence to sequence")
|
||||
}
|
||||
}
|
||||
|
||||
static void createArray (MyArray1& anArrPnt)
|
||||
{
|
||||
for (Standard_Integer j = 0; j < 2*REPEAT; j++) {
|
||||
PERF_START_METER("Create array")
|
||||
for (Standard_Integer i = anArrPnt.Lower(); i <= anArrPnt.Upper(); i++)
|
||||
anArrPnt(i).SetCoord ((double)i, (double)(i+1), (double)(i+2));
|
||||
PERF_STOP_METER("Create array")
|
||||
}
|
||||
}
|
||||
|
||||
static void assignArray (TColgp_Array1OfPnt& aDest, const TColgp_Array1OfPnt& aSrc)
|
||||
{
|
||||
for (Standard_Integer i = 0; i < 2*REPEAT; i++) {
|
||||
PERF_START_METER("Assign array to array")
|
||||
aDest = aSrc;
|
||||
PERF_STOP_METER("Assign array to array")
|
||||
}
|
||||
}
|
||||
|
||||
template <class MyBaseCollPnt>
|
||||
void assignCollection (MyBaseCollPnt& aDest,
|
||||
const MyBaseCollPnt& aSrc,
|
||||
const char * MeterName)
|
||||
{
|
||||
for (Standard_Integer i = 0; i < REPEAT; i++) {
|
||||
perf_start_meter (MeterName);
|
||||
aDest.Assign(aSrc);
|
||||
perf_stop_meter (MeterName);
|
||||
}
|
||||
}
|
||||
|
||||
static void assignArray (MyArray1& aDest, const MyArray1& aSrc)
|
||||
{
|
||||
for (Standard_Integer i = 0; i < 2*REPEAT; i++) {
|
||||
PERF_START_METER("Assign array to array")
|
||||
aDest = aSrc;
|
||||
PERF_STOP_METER("Assign array to array")
|
||||
}
|
||||
}
|
||||
|
||||
static void checkArray (const Standard_Boolean isNewColl)
|
||||
{
|
||||
if (isNewColl) {
|
||||
MyArray1 anArrPnt (1, 100000), anArrPnt1 (1, 100000);
|
||||
@ -64,17 +147,11 @@ void checkArray (const Standard_Boolean isNewColl)
|
||||
printAllMeters ();
|
||||
}
|
||||
|
||||
static Handle(NCollection_BaseAllocator) anAlloc[2];
|
||||
|
||||
Handle(NCollection_BaseAllocator) getAlloc (const int i)
|
||||
{
|
||||
return i == 0 ? anAlloc[0]: anAlloc[1];
|
||||
}
|
||||
|
||||
void checkSequence (const Standard_Boolean isNewColl,
|
||||
const Standard_Boolean isIncr)
|
||||
static void checkSequence (const Standard_Boolean isNewColl,
|
||||
const Standard_Boolean isIncr)
|
||||
{
|
||||
if (isNewColl) {
|
||||
Handle(NCollection_BaseAllocator) anAlloc[2];
|
||||
if (isIncr) {
|
||||
anAlloc[0] = new NCollection_IncAllocator;
|
||||
anAlloc[1] = new NCollection_IncAllocator;
|
||||
@ -134,7 +211,7 @@ static Standard_Integer QANColCheckSequence(Draw_Interpretor& di, Standard_Integ
|
||||
return 0;
|
||||
}
|
||||
|
||||
void QANCollection::Commands1(Draw_Interpretor& theCommands) {
|
||||
void QANCollection::CommandsSimple(Draw_Interpretor& theCommands) {
|
||||
const char *group = "QANCollection";
|
||||
|
||||
// from agvCollTest/src/AgvColEXE/TestEXE.cxx
|
||||
761
src/QANCollection/QANCollection_Test.cxx
Normal file
761
src/QANCollection/QANCollection_Test.cxx
Normal file
@ -0,0 +1,761 @@
|
||||
// Created on: 2004-03-05
|
||||
// Created by: Mikhail KUZMITCHEV
|
||||
// Copyright (c) 2004-2014 OPEN CASCADE SAS
|
||||
//
|
||||
// This file is part of Open CASCADE Technology software library.
|
||||
//
|
||||
// This library is free software; you can redistribute it and/or modify it under
|
||||
// the terms of the GNU Lesser General Public License version 2.1 as published
|
||||
// by the Free Software Foundation, with special exception defined in the file
|
||||
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
|
||||
// distribution for complete text of the license and disclaimer of any warranty.
|
||||
//
|
||||
// Alternatively, this file may be used under the terms of Open CASCADE
|
||||
// commercial license or contractual agreement.
|
||||
|
||||
#include <QANCollection.hxx>
|
||||
#include <QANCollection_Common.hxx>
|
||||
|
||||
#include <Draw.hxx>
|
||||
#include <Draw_Interpretor.hxx>
|
||||
|
||||
#include <gp_Pnt.hxx>
|
||||
|
||||
#define ItemType gp_Pnt
|
||||
#define Key1Type Standard_Real
|
||||
#define Key2Type Standard_Integer
|
||||
|
||||
#include <NCollection_DefineArray1.hxx>
|
||||
#include <NCollection_DefineHArray1.hxx>
|
||||
////////////////////////////////DEFINE_ARRAY1(QANCollection_Array1,QANCollection_BaseCol,ItemType)
|
||||
////////////////////////////////DEFINE_HARRAY1(QANCollection_HArray1,QANCollection_Array1)
|
||||
DEFINE_ARRAY1(QANCollection_Array1Func,QANCollection_BaseColFunc,ItemType)
|
||||
DEFINE_HARRAY1(QANCollection_HArray1Func,QANCollection_Array1Func)
|
||||
IMPLEMENT_HARRAY1(QANCollection_HArray1Func)
|
||||
|
||||
#include <NCollection_DefineArray2.hxx>
|
||||
#include <NCollection_DefineHArray2.hxx>
|
||||
////////////////////////////////DEFINE_ARRAY2(QANCollection_Array2,QANCollection_BaseCol,ItemType)
|
||||
////////////////////////////////DEFINE_HARRAY2(QANCollection_HArray2,QANCollection_Array2)
|
||||
DEFINE_ARRAY2(QANCollection_Array2Func,QANCollection_BaseColFunc,ItemType)
|
||||
DEFINE_HARRAY2(QANCollection_HArray2Func,QANCollection_Array2Func)
|
||||
IMPLEMENT_HARRAY2(QANCollection_HArray2Func)
|
||||
|
||||
#include <NCollection_DefineMap.hxx>
|
||||
#include <NCollection_DefineDataMap.hxx>
|
||||
#include <NCollection_DefineDoubleMap.hxx>
|
||||
#include <NCollection_DefineIndexedMap.hxx>
|
||||
#include <NCollection_DefineIndexedDataMap.hxx>
|
||||
////////////////////////////////DEFINE_MAP(QANCollection_Map,QANCollection_Key1BaseCol,Key1Type)
|
||||
////////////////////////////////DEFINE_DATAMAP(QANCollection_DataMap,QANCollection_BaseCol,Key1Type,ItemType)
|
||||
////////////////////////////////DEFINE_DOUBLEMAP(QANCollection_DoubleMap,QANCollection_Key2BaseCol,Key1Type,Key2Type)
|
||||
////////////////////////////////DEFINE_INDEXEDMAP(QANCollection_IndexedMap,QANCollection_Key1BaseCol,Key1Type)
|
||||
////////////////////////////////DEFINE_INDEXEDDATAMAP(QANCollection_IDMap,QANCollection_BaseCol,Key1Type,ItemType)
|
||||
DEFINE_MAP(QANCollection_MapFunc,QANCollection_Key1BaseColFunc,Key1Type)
|
||||
DEFINE_DATAMAP(QANCollection_DataMapFunc,QANCollection_BaseColFunc,Key1Type,ItemType)
|
||||
DEFINE_DOUBLEMAP(QANCollection_DoubleMapFunc,QANCollection_Key2BaseColFunc,Key1Type,Key2Type)
|
||||
DEFINE_INDEXEDMAP(QANCollection_IndexedMapFunc,QANCollection_Key1BaseColFunc,Key1Type)
|
||||
DEFINE_INDEXEDDATAMAP(QANCollection_IDMapFunc,QANCollection_BaseColFunc,Key1Type,ItemType)
|
||||
|
||||
#include <NCollection_DefineList.hxx>
|
||||
////////////////////////////////DEFINE_LIST(QANCollection_List,QANCollection_BaseCol,ItemType)
|
||||
DEFINE_LIST(QANCollection_ListFunc,QANCollection_BaseColFunc,ItemType)
|
||||
|
||||
#include <NCollection_DefineSequence.hxx>
|
||||
#include <NCollection_DefineHSequence.hxx>
|
||||
////////////////////////////////DEFINE_SEQUENCE(QANCollection_Sequence,QANCollection_BaseCol,ItemType)
|
||||
////////////////////////////////DEFINE_HSEQUENCE(QANCollection_HSequence,QANCollection_Sequence)
|
||||
DEFINE_SEQUENCE(QANCollection_SequenceFunc,QANCollection_BaseColFunc,ItemType)
|
||||
DEFINE_HSEQUENCE(QANCollection_HSequenceFunc,QANCollection_SequenceFunc)
|
||||
IMPLEMENT_HSEQUENCE(QANCollection_HSequenceFunc)
|
||||
|
||||
// HashCode and IsEquel must be defined for key types of maps
|
||||
Standard_Integer HashCode(const gp_Pnt thePnt, int theUpper)
|
||||
{
|
||||
return HashCode(thePnt.X(),theUpper);
|
||||
}
|
||||
|
||||
Standard_Boolean IsEqual(const gp_Pnt& theP1, const gp_Pnt& theP2)
|
||||
{
|
||||
return theP1.IsEqual(theP2,gp::Resolution());
|
||||
}
|
||||
|
||||
////////////////////////////////void printCollection (QANCollection_Key1BaseCol& aColl,
|
||||
template <class Coll>
|
||||
void printCollection (Coll& aColl, const char * str)
|
||||
{
|
||||
printf ("%s:\n",str);
|
||||
Standard_Integer iSize = aColl.Size();
|
||||
////////////////////////////////QANCollection_Key1BaseCol::Iterator& anIter = aColl.CreateIterator();
|
||||
typename Coll::Iterator anIter (aColl);
|
||||
if (!anIter.More())
|
||||
{
|
||||
if (iSize==0)
|
||||
printf (" <Empty collection>\n");
|
||||
else
|
||||
printf ("Error : empty collection has size==%d",iSize);
|
||||
}
|
||||
else
|
||||
{
|
||||
printf (" Size==%d\n",iSize);
|
||||
for (; anIter.More(); anIter.Next())
|
||||
PrintItem(anIter.Value());
|
||||
}
|
||||
}
|
||||
|
||||
////////////////////////////////void AssignCollection (QANCollection_BaseCol& aCollSrc,
|
||||
//////////////////////////////// QANCollection_BaseCol& aCollDst)
|
||||
template <class Coll>
|
||||
void AssignCollection (Coll& aCollSrc, Coll& aCollDst)
|
||||
{
|
||||
printCollection (aCollSrc,"Source collection");
|
||||
aCollDst.Assign(aCollSrc);
|
||||
printCollection (aCollDst,"Target collection");
|
||||
}
|
||||
|
||||
// ===================== Test methods of Array1 type ==========================
|
||||
////////////////////////////////void TestArray1 (QANCollection_Array1& theA1)
|
||||
static void TestArray1 (QANCollection_Array1Func& theA1)
|
||||
{
|
||||
// Bounds
|
||||
Standard_Integer iLow=theA1.Lower();
|
||||
Standard_Integer iUpp=theA1.Upper();
|
||||
Standard_Integer i;
|
||||
|
||||
printf ("Info: testing Array1(%d,%d), %s\n",
|
||||
iLow, iUpp, (theA1.IsDeletable()?"deletable":"frozen"));
|
||||
// C-array constructor, Length, Init
|
||||
ItemType anItem;
|
||||
Random(anItem);
|
||||
theA1.Init (anItem);
|
||||
ItemType * rBlock = new ItemType[theA1.Length()];
|
||||
////////////////////////////////QANCollection_Array1 aCArr(*rBlock, iLow-100, iUpp-100);
|
||||
QANCollection_Array1Func aCArr(*rBlock, iLow-100, iUpp-100);
|
||||
printf (" created the same sized preallocated array (%d,%d), %s\n",
|
||||
aCArr.Lower(),aCArr.Upper(),(aCArr.IsDeletable()?"deletable":"frozen"));
|
||||
// *Value, operator()
|
||||
for (i=iLow+1; i<iUpp; i++)
|
||||
{
|
||||
Random (aCArr.ChangeValue (i-101));
|
||||
aCArr.SetValue (i-100, ItemType(aCArr.Value(i-101)));
|
||||
aCArr(i-99) = aCArr(i-100) = aCArr(i-101);
|
||||
}
|
||||
// Handle, copy constructor (including operator=)
|
||||
////////////////////////////////Handle(QANCollection_HArray1) aHa = new QANCollection_HArray1(aCArr);
|
||||
Handle(QANCollection_HArray1Func) aHa = new QANCollection_HArray1Func(aCArr);
|
||||
// Assign
|
||||
AssignCollection (aHa->ChangeArray1(), theA1);
|
||||
}
|
||||
|
||||
// ===================== Test methods of Array2 type ==========================
|
||||
////////////////////////////////void TestArray2 (QANCollection_Array2& theA2)
|
||||
static void TestArray2 (QANCollection_Array2Func& theA2)
|
||||
{
|
||||
// Bounds
|
||||
Standard_Integer iLR=theA2.LowerRow(), iLC=theA2.LowerCol();
|
||||
Standard_Integer iUR=theA2.UpperRow(), iUC=theA2.UpperCol();
|
||||
Standard_Integer i,j;
|
||||
|
||||
printf ("Info: testing Array2 (%d,%d)(%d,%d), %s\n",
|
||||
iLR, iUR, iLC, iUC, (theA2.IsDeletable()?"deletable":"frozen"));
|
||||
// C-array constructor, Length, Init, RowLength, ColLength
|
||||
ItemType anItem;
|
||||
Random(anItem);
|
||||
theA2.Init (anItem);
|
||||
ItemType * rBlock = new ItemType[theA2.Length()];
|
||||
////////////////////////////////QANCollection_Array2 aCArr(*rBlock, iLR-100, iUR-100, iLC, iUC);
|
||||
QANCollection_Array2Func aCArr(*rBlock, iLR-100, iUR-100, iLC, iUC);
|
||||
printf (" created the same sized preallocated array (%d*%d), %s\n",
|
||||
aCArr.RowLength(), aCArr.ColLength(),
|
||||
(aCArr.IsDeletable()?"deletable":"frozen"));
|
||||
// *Value, operator()
|
||||
for (i=iLR+1; i<iUR; i++)
|
||||
{
|
||||
for (j=iLC; j<=iUC; j++)
|
||||
{
|
||||
Random (aCArr.ChangeValue (i-101, j));
|
||||
aCArr.SetValue (i-100, j,
|
||||
ItemType(aCArr.Value(i-101,j)));
|
||||
aCArr(i-99,j) = aCArr(i-100,j) = aCArr(i-101,j);
|
||||
}
|
||||
}
|
||||
// Handle, copy constructor (including operator=)
|
||||
////////////////////////////////Handle(QANCollection_HArray2) aHa = new QANCollection_HArray2(aCArr);
|
||||
Handle(QANCollection_HArray2Func) aHa = new QANCollection_HArray2Func(aCArr);
|
||||
// Assign
|
||||
AssignCollection (aHa->ChangeArray2(), theA2);
|
||||
}
|
||||
|
||||
// ===================== Test methods of List type ==========================
|
||||
////////////////////////////////void TestList (QANCollection_List& theL)
|
||||
static void TestList (QANCollection_ListFunc& theL)
|
||||
{
|
||||
// Extent
|
||||
Standard_Integer iExt=theL.Extent();
|
||||
Standard_Integer i;
|
||||
|
||||
printf ("Info: testing List(%d)\n", iExt);
|
||||
// Append(2), Prepend(2), InsertBefore(2), InsertAfter(2),
|
||||
// Remove, RemoveFirst, First, Last
|
||||
ItemType anItem;
|
||||
////////////////////////////////QANCollection_List aL, aL1;
|
||||
QANCollection_ListFunc aL, aL1;
|
||||
for (i=0; i<4; i++)
|
||||
{
|
||||
Random (anItem);
|
||||
aL.Append (anItem); // #1
|
||||
aL.Append (aL1); // #2
|
||||
Random (anItem);
|
||||
aL1.Prepend (anItem); // #3
|
||||
aL1.Prepend (aL); // #4
|
||||
////////////////////////////////QANCollection_List::Iterator anI(theL);
|
||||
QANCollection_ListFunc::Iterator anI(theL);
|
||||
if (anI.More())
|
||||
{
|
||||
Random (anItem);
|
||||
theL.InsertBefore (anItem, anI); // #5
|
||||
theL.InsertBefore (aL1, anI); // #6
|
||||
Random (anItem);
|
||||
theL.InsertAfter (anItem, anI); // #7
|
||||
theL.InsertAfter (aL, anI); // #8
|
||||
theL.Remove (anI); // #9
|
||||
if (theL.Extent() > 0)
|
||||
theL.RemoveFirst(); // #10
|
||||
}
|
||||
else
|
||||
{
|
||||
theL.Prepend (anItem);
|
||||
PrintItem(theL.First());
|
||||
PrintItem(theL.Last());
|
||||
}
|
||||
}
|
||||
// Copy constructor + operator=
|
||||
////////////////////////////////aL = QANCollection_List(theL);
|
||||
aL = QANCollection_ListFunc(theL);
|
||||
|
||||
// Assign
|
||||
AssignCollection (theL, aL);
|
||||
|
||||
// Clear
|
||||
aL.Clear();
|
||||
}
|
||||
|
||||
// ===================== Test methods of Sequence type ========================
|
||||
////////////////////////////////void TestSequence (QANCollection_Sequence& theS)
|
||||
static void TestSequence (QANCollection_SequenceFunc& theS)
|
||||
{
|
||||
Standard_Integer i;
|
||||
|
||||
printf ("Info: testing Sequence\n");
|
||||
// Append(2)
|
||||
ItemType anItem;
|
||||
////////////////////////////////QANCollection_Sequence aS, aS1;
|
||||
QANCollection_SequenceFunc aS, aS1;
|
||||
// Append(2), Prepend(2), InsertBefore(2), InsertAfter(2),
|
||||
// Remove, RemoveFirst, First, Last
|
||||
for (i=0; i<4; i++)
|
||||
{
|
||||
Random (anItem);
|
||||
aS.Append (anItem); // #1
|
||||
aS.Append (aS1); // #2
|
||||
Random (anItem);
|
||||
aS1.Prepend (anItem); // #3
|
||||
aS1.Prepend (aS); // #4
|
||||
if (theS.Length() > 0)
|
||||
{
|
||||
Random (anItem);
|
||||
theS.InsertBefore (1, anItem); // #5
|
||||
theS.InsertBefore (2, aS1); // #6
|
||||
Random (anItem);
|
||||
theS.InsertAfter (1, anItem); // #7
|
||||
theS.InsertAfter (2, aS); // #8
|
||||
theS.Remove (1); // #9
|
||||
if (theS.Length() > 0)
|
||||
theS.Remove(1); // #10
|
||||
}
|
||||
else
|
||||
{
|
||||
theS.Prepend (anItem);
|
||||
PrintItem(theS.First());
|
||||
PrintItem(theS.Last());
|
||||
}
|
||||
}
|
||||
|
||||
// ()
|
||||
PrintItem(theS(1));
|
||||
|
||||
// Handle, Split
|
||||
////////////////////////////////Handle(QANCollection_HSequence) aHS = new QANCollection_HSequence(aS1);
|
||||
Handle(QANCollection_HSequenceFunc) aHS = new QANCollection_HSequenceFunc(aS1);
|
||||
theS.Split (3, aHS->ChangeSequence());
|
||||
|
||||
// Assign
|
||||
AssignCollection (theS, aS);
|
||||
|
||||
// Clear
|
||||
aS.Clear();
|
||||
}
|
||||
|
||||
// ===================== Test methods of Map type =============================
|
||||
////////////////////////////////void TestMap (QANCollection_Map& theM)
|
||||
static void TestMap (QANCollection_MapFunc& theM)
|
||||
{
|
||||
// Extent
|
||||
Standard_Integer iExt=theM.Extent();
|
||||
Standard_Integer i;
|
||||
|
||||
printf ("Info: testing Map(l=%d)\n", iExt);
|
||||
theM.Statistics(cout);
|
||||
// Resize
|
||||
theM.ReSize(8);
|
||||
theM.Statistics(cout);
|
||||
cout.flush();
|
||||
// Constructor
|
||||
////////////////////////////////QANCollection_Map aM;
|
||||
QANCollection_MapFunc aM;
|
||||
// Add
|
||||
Key1Type aKey;
|
||||
for (i=0; i<8; i++)
|
||||
{
|
||||
Random (aKey);
|
||||
aM.Add (aKey);
|
||||
}
|
||||
// Contains, Remove
|
||||
if (!aM.Contains(aKey))
|
||||
{
|
||||
printf("Error : map says that it does not contain its key ");
|
||||
PrintItem(aKey);
|
||||
}
|
||||
else
|
||||
{
|
||||
aM.Remove(aKey);
|
||||
printf(" successfully removed item, l=%d\n", aM.Size());
|
||||
}
|
||||
// Copy constructor (including operator=)
|
||||
////////////////////////////////QANCollection_Map aM2 = QANCollection_Map(aM);
|
||||
QANCollection_MapFunc aM2 = QANCollection_MapFunc(aM);
|
||||
// Assign
|
||||
AssignCollection (aM2,theM);
|
||||
|
||||
// Clear
|
||||
aM.Clear();
|
||||
}
|
||||
|
||||
// ===================== Test methods of DataMap type =========================
|
||||
////////////////////////////////void TestDataMap (QANCollection_DataMap& theM)
|
||||
static void TestDataMap (QANCollection_DataMapFunc& theM)
|
||||
{
|
||||
// Extent
|
||||
Standard_Integer iExt=theM.Extent();
|
||||
Standard_Integer i;
|
||||
|
||||
printf ("Info: testing DataMap(l=%d)\n", iExt);
|
||||
theM.Statistics(cout);
|
||||
// Resize
|
||||
theM.ReSize(8);
|
||||
theM.Statistics(cout);
|
||||
cout.flush();
|
||||
// Constructor
|
||||
////////////////////////////////QANCollection_DataMap aM;
|
||||
QANCollection_DataMapFunc aM;
|
||||
// Bind, Find, ChangeFind, ()
|
||||
Key1Type aKey;
|
||||
ItemType anItem;
|
||||
for (i=0; i<8; i++)
|
||||
{
|
||||
Random (aKey);
|
||||
Random (anItem);
|
||||
aM.Bind (aKey, anItem);
|
||||
PrintItem(aM.Find(aKey));
|
||||
Random(aM(aKey));
|
||||
}
|
||||
// IsBound, UnBind
|
||||
if (!aM.IsBound(aKey))
|
||||
{
|
||||
printf("Error : map says that it does not contain its key ");
|
||||
PrintItem(aKey);
|
||||
}
|
||||
else
|
||||
{
|
||||
aM.UnBind(aKey);
|
||||
printf(" successfully unbound the key, l=%d\n", aM.Size());
|
||||
}
|
||||
// Copy constructor (including operator=)
|
||||
////////////////////////////////theM = QANCollection_DataMap(aM);
|
||||
theM = QANCollection_DataMapFunc(aM);
|
||||
// Assign - prohibited
|
||||
// AssignCollection (aM2,theM);
|
||||
printCollection (theM, "DataMap:");
|
||||
|
||||
// Clear
|
||||
aM.Clear();
|
||||
}
|
||||
|
||||
|
||||
// ===================== Test methods of DoubleMap type =======================
|
||||
////////////////////////////////void TestDoubleMap (QANCollection_DoubleMap& theM)
|
||||
static void TestDoubleMap (QANCollection_DoubleMapFunc& theM)
|
||||
{
|
||||
// Extent
|
||||
Standard_Integer iExt=theM.Extent();
|
||||
Standard_Integer i;
|
||||
|
||||
printf ("Info: testing DoubleMap(l=%d)\n", iExt);
|
||||
theM.Statistics(cout);
|
||||
// Resize
|
||||
theM.ReSize(8);
|
||||
theM.Statistics(cout);
|
||||
cout.flush();
|
||||
// Constructor
|
||||
////////////////////////////////QANCollection_DoubleMap aM;
|
||||
QANCollection_DoubleMapFunc aM;
|
||||
// Bind, Find?,
|
||||
Key1Type aKey1;
|
||||
Key2Type aKey2;
|
||||
for (i=0; i<8; i++)
|
||||
{
|
||||
Random (aKey1);
|
||||
Random (aKey2);
|
||||
aM.Bind (aKey1, aKey2);
|
||||
PrintItem(aM.Find1(aKey1));
|
||||
if (!aM.IsBound1(aKey1))
|
||||
{
|
||||
printf("Error : map says that it does not contain its key ");
|
||||
PrintItem(aKey1);
|
||||
}
|
||||
PrintItem(aM.Find2(aKey2));
|
||||
if (!aM.IsBound2(aKey2))
|
||||
{
|
||||
printf("Error : map says that it does not contain its key ");
|
||||
PrintItem(aKey2);
|
||||
}
|
||||
}
|
||||
// AreBound, UnBind
|
||||
if (!aM.AreBound(aKey1,aKey2))
|
||||
{
|
||||
printf("Error : map says that it does not contain its keys ");
|
||||
PrintItem(aKey1);
|
||||
PrintItem(aKey2);
|
||||
}
|
||||
else
|
||||
{
|
||||
if (aM.UnBind2(aKey2))
|
||||
printf(" successfully unbound the key, l=%d\n", aM.Size());
|
||||
if (aM.UnBind1(aKey1))
|
||||
printf("Error : unbound both keys?!\n");
|
||||
}
|
||||
// Copy constructor (including operator=)
|
||||
////////////////////////////////theM = QANCollection_DoubleMap(aM);
|
||||
theM = QANCollection_DoubleMapFunc(aM);
|
||||
// Assign - prohibited
|
||||
// AssignCollection (aM2,theM);
|
||||
printCollection (theM, "DoubleMap:");
|
||||
|
||||
// Clear
|
||||
aM.Clear();
|
||||
}
|
||||
|
||||
// ===================== Test methods of IndexedMap type ======================
|
||||
////////////////////////////////void TestIndexedMap (QANCollection_IndexedMap& theM)
|
||||
static void TestIndexedMap (QANCollection_IndexedMapFunc& theM)
|
||||
{
|
||||
// Extent
|
||||
Standard_Integer iExt=theM.Extent();
|
||||
Standard_Integer i;
|
||||
|
||||
printf ("Info: testing IndexedMap(l=%d)\n", iExt);
|
||||
theM.Statistics(cout);
|
||||
// Resize
|
||||
theM.ReSize(8);
|
||||
theM.Statistics(cout);
|
||||
cout.flush();
|
||||
// Constructor
|
||||
////////////////////////////////QANCollection_IndexedMap aM;
|
||||
QANCollection_IndexedMapFunc aM;
|
||||
// Add, FindKey, FindIndex
|
||||
Key1Type aKey;
|
||||
for (i=0; i<8; i++)
|
||||
{
|
||||
Random (aKey);
|
||||
aM.Add (aKey);
|
||||
Standard_Integer iIndex=aM.FindIndex(aKey);
|
||||
printf (" added a key, i=%d, k=",iIndex);
|
||||
PrintItem(aM(iIndex));
|
||||
}
|
||||
// Contains, Remove
|
||||
if (!aM.Contains(aM.FindKey(aM.FindIndex(aKey))))
|
||||
{
|
||||
printf("Error : map says that it does not contain its key ");
|
||||
PrintItem(aKey);
|
||||
}
|
||||
else
|
||||
{
|
||||
aM.RemoveLast();
|
||||
printf(" successfully removed item, l=%d\n", aM.Size());
|
||||
}
|
||||
// Substitute
|
||||
Random(aKey);
|
||||
aM.Substitute(1,aKey);
|
||||
// Copy constructor (including operator=)
|
||||
////////////////////////////////QANCollection_IndexedMap aM2 = QANCollection_IndexedMap(aM);
|
||||
QANCollection_IndexedMapFunc aM2 = QANCollection_IndexedMapFunc(aM);
|
||||
// Assign
|
||||
AssignCollection (aM2,theM);
|
||||
|
||||
// Clear
|
||||
aM.Clear();
|
||||
}
|
||||
|
||||
// ===================== Test methods of IndexedDataMap type ==================
|
||||
////////////////////////////////void TestIndexedDataMap (QANCollection_IDMap& theM)
|
||||
static void TestIndexedDataMap (QANCollection_IDMapFunc& theM)
|
||||
{
|
||||
// Extent
|
||||
Standard_Integer iExt=theM.Extent();
|
||||
Standard_Integer i;
|
||||
|
||||
printf ("Info: testing IndexedDataMap(l=%d)\n", iExt);
|
||||
theM.Statistics(cout);
|
||||
// Resize
|
||||
theM.ReSize(8);
|
||||
theM.Statistics(cout);
|
||||
cout.flush();
|
||||
// Constructor
|
||||
////////////////////////////////QANCollection_IDMap aM;
|
||||
QANCollection_IDMapFunc aM;
|
||||
// Add, FindKey, FindIndex, FindFromIndex, Change..., ()
|
||||
Key1Type aKey;
|
||||
ItemType anItem;
|
||||
for (i=0; i<8; i++)
|
||||
{
|
||||
Random (aKey);
|
||||
Random (anItem);
|
||||
aM.Add (aKey, anItem);
|
||||
Standard_Integer iIndex=aM.FindIndex(aKey);
|
||||
printf (" added a key, i=%d, k=",iIndex);
|
||||
PrintItem(aM.FindKey(iIndex));
|
||||
PrintItem(aM(iIndex));
|
||||
Random(aM.ChangeFromIndex(iIndex));
|
||||
}
|
||||
// Contains, Remove, FindFromKey
|
||||
if (!aM.Contains(aM.FindKey(aM.FindIndex(aKey))))
|
||||
{
|
||||
printf("Error : map says that it does not contain its key ");
|
||||
PrintItem(aKey);
|
||||
}
|
||||
else
|
||||
{
|
||||
anItem = aM.FindFromKey(aKey);
|
||||
aM.RemoveLast();
|
||||
printf(" successfully removed item, l=%d\n", aM.Size());
|
||||
}
|
||||
// Substitute
|
||||
Random(aKey);
|
||||
aM.Substitute (1, aKey, anItem);
|
||||
// Copy constructor (including operator=)
|
||||
////////////////////////////////theM = QANCollection_IDMap(aM);
|
||||
theM = QANCollection_IDMapFunc(aM);
|
||||
// Assign - prohibited
|
||||
// AssignCollection (aM2,theM);
|
||||
printCollection (theM, "DoubleMap:");
|
||||
|
||||
// Clear
|
||||
aM.Clear();
|
||||
}
|
||||
|
||||
//=======================================================================
|
||||
//function : CheckArguments1
|
||||
//purpose :
|
||||
//=======================================================================
|
||||
Standard_Integer CheckArguments1(Draw_Interpretor& di, Standard_Integer argc, const char ** argv, Standard_Integer& Lower, Standard_Integer& Upper)
|
||||
{
|
||||
if ( argc != 3) {
|
||||
di << "Usage : " << argv[0] << " Lower Upper" << "\n";
|
||||
return 1;
|
||||
}
|
||||
Lower = Draw::Atoi(argv[1]);
|
||||
Upper = Draw::Atoi(argv[2]);
|
||||
if ( Lower > Upper ) {
|
||||
di << "Lower > Upper" << "\n";
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
//=======================================================================
|
||||
//function : CheckArguments2
|
||||
//purpose :
|
||||
//=======================================================================
|
||||
Standard_Integer CheckArguments2(Draw_Interpretor& di, Standard_Integer argc, const char ** argv, Standard_Integer& LowerRow, Standard_Integer& UpperRow, Standard_Integer& LowerCol, Standard_Integer& UpperCol)
|
||||
{
|
||||
if ( argc != 5) {
|
||||
di << "Usage : " << argv[0] << " LowerRow UpperRow LowerCol UpperCol" << "\n";
|
||||
return 1;
|
||||
}
|
||||
LowerRow = Draw::Atoi(argv[1]);
|
||||
UpperRow = Draw::Atoi(argv[2]);
|
||||
LowerCol = Draw::Atoi(argv[3]);
|
||||
UpperCol = Draw::Atoi(argv[4]);
|
||||
if ( LowerRow > UpperRow ) {
|
||||
di << "LowerRow > UpperRow" << "\n";
|
||||
return 1;
|
||||
}
|
||||
if ( LowerCol > UpperCol ) {
|
||||
di << "LowerCol UpperCol> " << "\n";
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
//=======================================================================
|
||||
//function : QANColTestArray1
|
||||
//purpose :
|
||||
//=======================================================================
|
||||
static Standard_Integer QANColTestArray1(Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
|
||||
{
|
||||
Standard_Integer Lower, Upper;
|
||||
if ( CheckArguments1(di, argc, argv, Lower, Upper) ) {
|
||||
return 1;
|
||||
}
|
||||
QANCollection_Array1Func anArr1(Lower, Upper);
|
||||
TestArray1(anArr1);
|
||||
return 0;
|
||||
}
|
||||
|
||||
//=======================================================================
|
||||
//function : QANColTestArray2
|
||||
//purpose :
|
||||
//=======================================================================
|
||||
static Standard_Integer QANColTestArray2(Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
|
||||
{
|
||||
Standard_Integer LowerRow, UpperRow, LowerCol, UpperCol;
|
||||
if ( CheckArguments2(di, argc, argv, LowerRow, UpperRow, LowerCol, UpperCol) ) {
|
||||
return 1;
|
||||
}
|
||||
QANCollection_Array2Func anArr2(LowerRow, UpperRow, LowerCol, UpperCol);
|
||||
TestArray2(anArr2);
|
||||
return 0;
|
||||
}
|
||||
|
||||
//=======================================================================
|
||||
//function : QANColTestMap
|
||||
//purpose :
|
||||
//=======================================================================
|
||||
static Standard_Integer QANColTestMap(Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
|
||||
{
|
||||
if ( argc != 1) {
|
||||
di << "Usage : " << argv[0] << "\n";
|
||||
return 1;
|
||||
}
|
||||
QANCollection_MapFunc aMap;
|
||||
TestMap(aMap);
|
||||
return 0;
|
||||
}
|
||||
|
||||
//=======================================================================
|
||||
//function : QANColTestDataMap
|
||||
//purpose :
|
||||
//=======================================================================
|
||||
static Standard_Integer QANColTestDataMap(Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
|
||||
{
|
||||
if ( argc != 1) {
|
||||
di << "Usage : " << argv[0] << "\n";
|
||||
return 1;
|
||||
}
|
||||
QANCollection_DataMapFunc aDataMap;
|
||||
TestDataMap(aDataMap);
|
||||
return 0;
|
||||
}
|
||||
|
||||
//=======================================================================
|
||||
//function : QANColTestDoubleMap
|
||||
//purpose :
|
||||
//=======================================================================
|
||||
static Standard_Integer QANColTestDoubleMap(Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
|
||||
{
|
||||
if ( argc != 1) {
|
||||
di << "Usage : " << argv[0] << "\n";
|
||||
return 1;
|
||||
}
|
||||
QANCollection_DoubleMapFunc aDoubleMap;
|
||||
TestDoubleMap(aDoubleMap);
|
||||
return 0;
|
||||
}
|
||||
|
||||
//=======================================================================
|
||||
//function : QANColTestIndexedMap
|
||||
//purpose :
|
||||
//=======================================================================
|
||||
static Standard_Integer QANColTestIndexedMap(Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
|
||||
{
|
||||
if ( argc != 1) {
|
||||
di << "Usage : " << argv[0] << "\n";
|
||||
return 1;
|
||||
}
|
||||
QANCollection_IndexedMapFunc aIndexedMap;
|
||||
TestIndexedMap(aIndexedMap);
|
||||
return 0;
|
||||
}
|
||||
|
||||
//=======================================================================
|
||||
//function : QANColTestIndexedDataMap
|
||||
//purpose :
|
||||
//=======================================================================
|
||||
static Standard_Integer QANColTestIndexedDataMap(Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
|
||||
{
|
||||
if ( argc != 1) {
|
||||
di << "Usage : " << argv[0] << "\n";
|
||||
return 1;
|
||||
}
|
||||
QANCollection_IDMapFunc aIDMap;
|
||||
TestIndexedDataMap(aIDMap);
|
||||
return 0;
|
||||
}
|
||||
|
||||
//=======================================================================
|
||||
//function : QANColTestList
|
||||
//purpose :
|
||||
//=======================================================================
|
||||
static Standard_Integer QANColTestList(Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
|
||||
{
|
||||
if ( argc != 1) {
|
||||
di << "Usage : " << argv[0] << "\n";
|
||||
return 1;
|
||||
}
|
||||
QANCollection_ListFunc aList;
|
||||
TestList(aList);
|
||||
return 0;
|
||||
}
|
||||
|
||||
//=======================================================================
|
||||
//function : QANColTestSequence
|
||||
//purpose :
|
||||
//=======================================================================
|
||||
static Standard_Integer QANColTestSequence(Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
|
||||
{
|
||||
if ( argc != 1) {
|
||||
di << "Usage : " << argv[0] << "\n";
|
||||
return 1;
|
||||
}
|
||||
QANCollection_SequenceFunc aSeq;
|
||||
TestSequence(aSeq);
|
||||
return 0;
|
||||
}
|
||||
|
||||
void QANCollection::CommandsTest(Draw_Interpretor& theCommands) {
|
||||
const char *group = "QANCollection";
|
||||
|
||||
// from agvCollTest/src/CollectionEXE/FuncTestEXE.cxx
|
||||
theCommands.Add("QANColTestArray1", "QANColTestArray1", __FILE__, QANColTestArray1, group);
|
||||
theCommands.Add("QANColTestArray2", "QANColTestArray2", __FILE__, QANColTestArray2, group);
|
||||
theCommands.Add("QANColTestMap", "QANColTestMap", __FILE__, QANColTestMap, group);
|
||||
theCommands.Add("QANColTestDataMap", "QANColTestDataMap", __FILE__, QANColTestDataMap, group);
|
||||
theCommands.Add("QANColTestDoubleMap", "QANColTestDoubleMap", __FILE__, QANColTestDoubleMap, group);
|
||||
theCommands.Add("QANColTestIndexedMap", "QANColTestIndexedMap", __FILE__, QANColTestIndexedMap, group);
|
||||
theCommands.Add("QANColTestIndexedDataMap", "QANColTestIndexedDataMap", __FILE__, QANColTestIndexedDataMap, group);
|
||||
theCommands.Add("QANColTestList", "QANColTestList", __FILE__, QANColTestList, group);
|
||||
theCommands.Add("QANColTestSequence", "QANColTestSequence", __FILE__, QANColTestSequence, group);
|
||||
|
||||
return;
|
||||
}
|
||||
Loading…
x
Reference in New Issue
Block a user