OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-04-04 18:06:22 +03:00
Code Packages Releases Activity

0024742: Remove rarely used collection classes: Set

Browse Source 
Classes NCollection_Set and NCollection_HSet removed as unused (along with NCollection_DefineSet.hxx and NCollection_DefineHSet.hxx).

Classes TCollection_Set and TCollection_HSet removed (along with TCollection_SetIterator and TCollection_SetList nested classes).
Code previously using Set classes updated to equivalent use of Sequence (Adaptor3d and Visual3d packages) or TColStd_PackedMapOfInteger (BRepAlgo package).

In Adaptor3d_CurveOnSurface, calculation of continuity intervals refactored so as to build and store sorted sequence of reals, instead of collecting them to set, copying to array, and then sorting.
This commit is contained in:
dln 2014-04-08 12:55:04 +04:00 committed by abv
parent 6af4fe1c46
commit 54f7544df6
34 changed files with 353 additions and 1869 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/Adaptor3d/Adaptor3d_CurveOnSurface.cdl
View File

@ -40,10 +40,10 @@ uses
HCurve from Adaptor3d,
HCurve2d from Adaptor2d,
HSurface from Adaptor3d,
HArray1OfReal from TColStd,
HSequenceOfReal from TColStd,
Pnt2d from gp,
Vec2d from gp
raises NoSuchObject from Standard,
DomainError from Standard,
OutOfRange from Standard
@ -315,7 +315,7 @@ fields
myFirstSurf : HSurface from Adaptor3d;
myLastSurf : HSurface from Adaptor3d;
myIntervals : HArray1OfReal from TColStd;
myIntervals : HSequenceOfReal from TColStd;
myIntCont : Shape from GeomAbs;
end CurveOnSurface;

123
src/Adaptor3d/Adaptor3d_CurveOnSurface.cxx
View File

@ -15,6 +15,7 @@
#include <Adaptor3d_CurveOnSurface.ixx>
#include <Adaptor3d_HCurveOnSurface.hxx>
#include <gp_Pnt2d.hxx>
#include <gp_Vec2d.hxx>
#include <gp_Ax22d.hxx>
@ -30,22 +31,18 @@
#include <Geom2d_BezierCurve.hxx>
#include <Geom2d_BSplineCurve.hxx>
#include <Precision.hxx>
#include <Standard_Assert.hxx>
#include <TColgp_Array1OfPnt2d.hxx>
#include <TColgp_Array1OfPnt.hxx>
#include <TColStd_Array1OfReal.hxx>
#include <TColStd_Array1OfInteger.hxx>
#include <TColStd_HSequenceOfReal.hxx>
#include <Standard_NotImplemented.hxx>
#include <Adaptor3d_HCurveOnSurface.hxx>
#include <ElCLib.hxx>
#include <ElSLib.hxx>
#include <Adaptor3d_InterFunc.hxx>
#include <math_FunctionRoots.hxx>
#include <SortTools_StraightInsertionSortOfReal.hxx>
#include <TCollection_CompareOfReal.hxx>
#include <ElSLib.hxx>
#include <TColStd_SetIteratorOfSetOfReal.hxx>
#include <TColStd_SetOfReal.hxx>
#include <TColStd_HSetOfReal.hxx>
static gp_Pnt to3d(const gp_Pln& Pl, const gp_Pnt2d& P)
{
@ -782,6 +779,34 @@ GeomAbs_Shape Adaptor3d_CurveOnSurface::Continuity() const
return ContC;
}
// Auxiliary: adds roots of equation to sorted sequence of parameters
// along curve, keeping it sorted and avoiding repetitions (within tolerance Tol)
static void AddIntervals (const Handle(TColStd_HSequenceOfReal)& theParameters,
const math_FunctionRoots& theRoots, Standard_Real theTol)
{
if (! theRoots.IsDone() || theRoots.IsAllNull())
return;
Standard_Integer nsol = theRoots.NbSolutions();
for (Standard_Integer i = 1; i <= nsol; i++)
{
Standard_Real param = theRoots.Value(i);
if (param - theParameters->Value(1) < theTol) // skip param if equal to or less than theParameters(1)
continue;
for (Standard_Integer j=2; j <= theParameters->Length(); ++j)
{
Standard_Real aDelta = theParameters->Value(j) - param;
if (aDelta > theTol)
{
theParameters->InsertBefore (j, param);
break;
}
else if (aDelta >= -theTol) // param == theParameters(j) within Tol
break;
}
}
}
//=======================================================================
//function : NbIntervals
//purpose :
@ -793,90 +818,63 @@ Standard_Integer Adaptor3d_CurveOnSurface::NbIntervals
if(S == myIntCont && !myIntervals.IsNull())
return myIntervals->Length()-1;
Standard_Integer nu,nv,nc,i;
Standard_Integer nu,nv,nc;
nu=mySurface->NbUIntervals(S);
nv=mySurface->NbVIntervals(S);
Handle(TColStd_HSetOfReal) tmpIntervals = new TColStd_HSetOfReal;
TColStd_SetIteratorOfSetOfReal It;
TColStd_Array1OfReal TabU(1,nu+1);
TColStd_Array1OfReal TabV(1,nv+1);
Standard_Integer NbSample = 20;
Standard_Real U,V,Tdeb,Tfin;
Tdeb=myCurve->FirstParameter();
Tfin=myCurve->LastParameter();
nc=myCurve->NbIntervals(S);
TColStd_Array1OfReal TabC(1,nc+1);
myCurve->Intervals(TabC,S);
Standard_Real Tol= Precision::PConfusion()/10;
for (i=1;i<=nc+1;i++)
{tmpIntervals->Add(TabC(i));}
Standard_Integer nbpoint=nc+1;
Standard_Real Tol= Precision::PConfusion()/10;
// sorted sequence of parameters defining continuity intervals;
// started with own intervals of curve and completed by
// additional points coming from surface discontinuities
myIntervals = new TColStd_HSequenceOfReal;
for (Standard_Integer i = 1; i <= nc + 1; i++)
{
myIntervals->Append(TabC(i));
}
if (nu>1)
{ mySurface->UIntervals(TabU,S);
{
mySurface->UIntervals(TabU,S);
for(Standard_Integer iu = 2;iu <= nu; iu++)
{ U = TabU.Value(iu);
{
U = TabU.Value(iu);
Adaptor3d_InterFunc Func(myCurve,U,1);
math_FunctionRoots Resol(Func,Tdeb,Tfin,NbSample,Tol,Tol,Tol,0.);
if (Resol.IsDone())
{ if (!Resol.IsAllNull())
{ Standard_Integer nsol=Resol.NbSolutions();
for ( i=1;i<=nsol;i++)
{ Standard_Real param =Resol.Value(i);
{ Standard_Boolean insere=Standard_True;
for (It.Initialize(tmpIntervals->Set());It.More();It.Next())
{ if (Abs(param- It.Value())<=Tol)
insere=Standard_False;}
if (insere)
{nbpoint++;
tmpIntervals->Add(param);}
}
}
}
}
AddIntervals (myIntervals, Resol, Tol);
}
}
if (nv>1)
{ mySurface->VIntervals(TabV,S);
{
mySurface->VIntervals(TabV,S);
for(Standard_Integer iv = 2;iv <= nv; iv++)
{ V = TabV.Value(iv);
{
V = TabV.Value(iv);
Adaptor3d_InterFunc Func(myCurve,V,2);
math_FunctionRoots Resol(Func,Tdeb,Tfin,NbSample,Tol,Tol,Tol,0.);
if (Resol.IsDone())
{ if (!Resol.IsAllNull())
{ Standard_Integer nsol=Resol.NbSolutions();
for ( i=1;i<=nsol;i++)
{ Standard_Real param =Resol.Value(i);
{ Standard_Boolean insere=Standard_True;
for (It.Initialize(tmpIntervals->Set());It.More();It.Next())
{ if (Abs(param- It.Value())<=Tol)
insere=Standard_False;}
if (insere)
{nbpoint++;
tmpIntervals->Add(param);}
}
}
}
}
AddIntervals (myIntervals, Resol, Tol);
}
}
// for case intervals==1 and first point == last point SetOfReal
// for case intervals==1 and first point == last point SequenceOfReal
// contains only one value, therefore it is necessary to add second
// value into myIntervals which will be equal first value.
myIntervals = new TColStd_HArray1OfReal(1,nbpoint);
i=0;
for (It.Initialize(tmpIntervals->Set());It.More();It.Next())
{
++i;
myIntervals->SetValue(i,It.Value());
}
if( i==1 )
myIntervals->SetValue(2,myIntervals->Value(1));
if (myIntervals->Length() == 1)
myIntervals->Append (myIntervals->Value(1));
myIntCont = S;
return nbpoint-1;
return myIntervals->Length() - 1;
}
//=======================================================================
@ -888,11 +886,10 @@ void Adaptor3d_CurveOnSurface::Intervals(TColStd_Array1OfReal& T,
const GeomAbs_Shape S)
{
NbIntervals(S);
Standard_ASSERT_RAISE (T.Length() == myIntervals->Length(), "Error: Wrong size of array buffer in call to Adaptor3d_CurveOnSurface::Intervals");
for(Standard_Integer i=1; i<=myIntervals->Length(); i++) {
T(i) = myIntervals->Value(i);
}
TCollection_CompareOfReal comp;
SortTools_StraightInsertionSortOfReal::Sort(T,comp);
}
//=======================================================================

4
src/BRepAlgo/BRepAlgo_DSAccess.cdl
View File

@ -27,7 +27,7 @@ uses
Face from TopoDS,
Vertex from TopoDS,
ListOfInteger from TColStd,
SetOfInteger from TColStd,
PackedMapOfInteger from TColStd,
MapOfInteger from TColStd,
ListOfShape from TopTools,
State from TopAbs,
@ -345,7 +345,7 @@ fields
myEmptyListOfInteger : ListOfInteger from TColStd;
myCompoundWireMap : DataMapOfShapeShape from TopTools;
mySetOfKeepPoint : SetOfInteger from TColStd;
mySetOfKeepPoint : PackedMapOfInteger from TColStd;
friends

4
src/BRepAlgo/BRepAlgo_DSAccess.cxx
View File

@ -21,7 +21,7 @@
#include <TColStd_MapOfInteger.hxx>
#include <TColStd_IndexedMapOfInteger.hxx>
#include <TColStd_MapIteratorOfMapOfInteger.hxx>
#include <TColStd_SetIteratorOfSetOfInteger.hxx>
#include <TColStd_MapIteratorOfPackedMapOfInteger.hxx>
#include <TopTools_ListOfShape.hxx>
#include <TopTools_ListIteratorOfListOfShape.hxx>
@ -528,7 +528,7 @@ void BRepAlgo_DSAccess::ChangeEdgeSet
TopoDS_Compound C;
TopoDS_Edge E;
B.MakeCompound(C);
TColStd_SetOfInteger RPoint; //The points to be controlled
TColStd_PackedMapOfInteger RPoint; //The points to be controlled
TopOpeBRepDS_ListIteratorOfListOfInterference iter;
TopExp_Explorer exp(Old, TopAbs_EDGE);

4
src/NCollection/FILES
View File

@ -28,8 +28,6 @@ NCollection_HArray1.hxx
NCollection_Array2.hxx
NCollection_HArray2.hxx
NCollection_List.hxx
NCollection_Set.hxx
NCollection_HSet.hxx
NCollection_Map.hxx
NCollection_DataMap.hxx
NCollection_DoubleMap.hxx
@ -51,8 +49,6 @@ NCollection_DefineIndexedMap.hxx
NCollection_DefineIndexedDataMap.hxx
NCollection_DefineSequence.hxx
NCollection_DefineHSequence.hxx
NCollection_DefineSet.hxx
NCollection_DefineHSet.hxx
NCollection_BaseVector.hxx
NCollection_BaseVector.cxx

57
src/NCollection/NCollection_DefineHSet.hxx
View File

@ -1,57 +0,0 @@
// Created on: 2002-04-29
// 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 NCollection_DefineHSet_HeaderFile
#define NCollection_DefineHSet_HeaderFile
#include <Standard_DefineHandle.hxx>
#include <NCollection_DefineSet.hxx>
#include <MMgt_TShared.hxx>
// Declaration of Set class managed by Handle
#define DEFINE_HSET(HClassName, _SetType_) \
\
class HClassName : public _SetType_, \
public MMgt_TShared { \
public: \
inline HClassName (); \
inline HClassName (const _SetType_& anOther); \
inline const _SetType_& Set () const; \
inline _SetType_& ChangeSet (); \
DEFINE_STANDARD_RTTI (HClassName) \
}; \
\
DEFINE_STANDARD_HANDLE (HClassName, MMgt_TShared) \
\
inline HClassName::HClassName () : \
_SetType_(), \
MMgt_TShared() {} \
\
inline HClassName::HClassName (const _SetType_& anOther) : \
_SetType_(anOther), \
MMgt_TShared() {} \
\
inline const _SetType_& HClassName::Set () const \
{ return * (const _SetType_ *) this; } \
\
inline _SetType_& HClassName::ChangeSet () \
{ return * (_SetType_ *) this; } \
#define IMPLEMENT_HSET(HClassName) \
IMPLEMENT_STANDARD_HANDLE (HClassName, MMgt_TShared) \
IMPLEMENT_STANDARD_RTTIEXT (HClassName, MMgt_TShared)
#endif

34
src/NCollection/NCollection_DefineSet.hxx
View File

@ -1,34 +0,0 @@
// Created on: 2002-04-17
// 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.
// Automatically created from NCollection_Set.hxx by GAWK
// Purpose: A set is an unordered collection of items without
// duplications. To test for duplications the operators == and !=
// are used on the items.
// Inherits BaseList, adding the data item to each node.
#ifndef NCollection_DefineSet_HeaderFile
#define NCollection_DefineSet_HeaderFile
#include <NCollection_DefineBaseCollection.hxx>
#include <NCollection_Set.hxx>
// **************************************** Template for Set class ********
#define DEFINE_SET(_ClassName_, _BaseCollection_, TheItemType) \
typedef NCollection_Set<TheItemType > _ClassName_;
#endif

27
src/NCollection/NCollection_HSet.hxx
View File

@ -1,27 +0,0 @@
// Created on: 2002-04-29
// 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 NCollection_HSet_HeaderFile
#define NCollection_HSet_HeaderFile
#include <NCollection_DefineHSet.hxx>
#include <NCollection_Set.hxx>
// Declaration of Set class managed by Handle
#define NCOLLECTION_HSET(HClassName,Type) \
DEFINE_HSET(HClassName,NCollection_Set<Type >)
#endif

227
src/NCollection/NCollection_Set.hxx
View File

@ -1,227 +0,0 @@
// Created on: 2002-04-17
// 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 NCollection_Set_HeaderFile
#define NCollection_Set_HeaderFile
#include <NCollection_BaseCollection.hxx>
#include <NCollection_BaseList.hxx>
#include <NCollection_TListNode.hxx>
#include <NCollection_TListIterator.hxx>
/**
* Purpose: A set is an unordered collection of items without
* duplications. To test for duplications the operators == and !=
* are used on the items.
* Inherits BaseList, adding the data item to each node.
*/
template <class TheItemType> class NCollection_Set
: public NCollection_BaseCollection<TheItemType>,
public NCollection_BaseList
{
public:
typedef NCollection_TListNode<TheItemType> SetNode;
typedef NCollection_TListIterator<TheItemType> Iterator;
public:
// ---------- PUBLIC METHODS ------------
//! Constructor
NCollection_Set(const Handle(NCollection_BaseAllocator)& theAllocator=0L) :
NCollection_BaseCollection<TheItemType>(theAllocator),
NCollection_BaseList() {}
//! Copy constructor
NCollection_Set (const NCollection_Set& theOther) :
NCollection_BaseCollection<TheItemType>(theOther.myAllocator),
NCollection_BaseList()
{ *this = theOther; }
//! Size - Number of items
virtual Standard_Integer Size (void) const
{ return Extent(); }
//! Replace this list by the items of theOther collection
virtual void Assign (const NCollection_BaseCollection<TheItemType>& theOther)
{
if (this == &theOther)
return;
Clear();
TYPENAME NCollection_BaseCollection<TheItemType>::Iterator& anIter =
theOther.CreateIterator();
for (; anIter.More(); anIter.Next())
{
SetNode* pNew = new (this->myAllocator) SetNode(anIter.Value());
PAppend (pNew);
}
}
//! Replace this list by the items of theOther Set
NCollection_Set& operator= (const NCollection_Set& theOther)
{
if (this == &theOther)
return *this;
Clear ();
SetNode * pCur = (SetNode *) theOther.PFirst();
while (pCur)
{
SetNode* pNew = new (this->myAllocator) SetNode(pCur->Value());
PAppend (pNew);
pCur = (SetNode *) pCur->Next();
}
return *this;
}
//! Clear this set
void Clear (void)
{ PClear (SetNode::delNode, this->myAllocator); }
//! Add item
Standard_Boolean Add (const TheItemType& theItem)
{
Iterator anIter(*this);
while (anIter.More())
{
if (anIter.Value() == theItem)
return Standard_False;
anIter.Next();
}
SetNode * pNew = new (this->myAllocator) SetNode(theItem);
PPrepend (pNew);
return Standard_True;
}
//! Remove item
Standard_Boolean Remove (const TheItemType& theItem)
{
Iterator anIter(*this);
while (anIter.More())
{
if (anIter.Value() == theItem)
{
PRemove (anIter, SetNode::delNode, this->myAllocator);
return Standard_True;
}
anIter.Next();
}
return Standard_False;
}
//! Remove - wrapper against 'hiding' warnings
void Remove (Iterator& theIter)
{ NCollection_BaseList::PRemove (theIter,
SetNode::delNode,
this->myAllocator); }
//! Contains - item inclusion query
Standard_Boolean Contains (const TheItemType& theItem) const
{
Iterator anIter(*this);
for (; anIter.More(); anIter.Next())
if (anIter.Value() == theItem)
return Standard_True;
return Standard_False;
}
//! IsASubset
Standard_Boolean IsASubset (const NCollection_Set& theOther)
{
if (this == &theOther)
return Standard_True;
Iterator anIter(theOther);
for (; anIter.More(); anIter.Next())
if (!Contains(anIter.Value()))
return Standard_False;
return Standard_True;
}
//! IsAProperSubset
Standard_Boolean IsAProperSubset (const NCollection_Set& theOther)
{
if (myLength <= theOther.Extent())
return Standard_False;
Iterator anIter(theOther);
for (; anIter.More(); anIter.Next())
if (!Contains(anIter.Value()))
return Standard_False;
return Standard_True;
}
//! Union
void Union (const NCollection_Set& theOther)
{
if (this == &theOther)
return;
Iterator anIter(theOther);
Iterator aMyIter;
Standard_Integer i, iLength=myLength;
for (; anIter.More(); anIter.Next())
{
Standard_Boolean isIn=Standard_False;
const TheItemType& theItem = anIter.Value();
for (aMyIter.Init(*this), i=1;
i<=iLength;
aMyIter.Next(), i++)
if (theItem == aMyIter.Value())
isIn = Standard_True;
if (!isIn)
{
SetNode * pNew = new (this->myAllocator) SetNode(theItem);
PAppend (pNew);
}
}
}
//! Intersection
void Intersection (const NCollection_Set& theOther)
{
if (this == &theOther)
return;
Iterator anIter(*this);
while (anIter.More())
if (theOther.Contains(anIter.Value()))
anIter.Next();
else
NCollection_BaseList::PRemove (anIter, SetNode::delNode, this->myAllocator);
}
//! Difference (Subtraction)
void Difference (const NCollection_Set& theOther)
{
if (this == &theOther)
return;
Iterator anIter(*this);
while (anIter.More())
if (theOther.Contains(anIter.Value()))
NCollection_BaseList::PRemove (anIter, SetNode::delNode, this->myAllocator);
else
anIter.Next();
}
//! Destructor - clears the List
~NCollection_Set (void)
{ Clear(); }
private:
// ----------- PRIVATE METHODS -----------
//! Creates Iterator for use on BaseCollection
virtual TYPENAME NCollection_BaseCollection<TheItemType>::Iterator&
CreateIterator(void) const
{ return *(new (this->IterAllocator()) Iterator(*this)); }
};
#endif

17
src/QANCollection/QANCollection2.cxx
View File

@ -39,7 +39,6 @@ Standard_Boolean IsEqual(const gp_Pnt& theP1, const gp_Pnt& theP2)
IMPLEMENT_HARRAY1(QANCollection_HArray1Func)
IMPLEMENT_HARRAY2(QANCollection_HArray2Func)
IMPLEMENT_HSET(QANCollection_HSetFunc)
IMPLEMENT_HSEQUENCE(QANCollection_HSequenceFunc)
//=======================================================================
@ -207,21 +206,6 @@ static Standard_Integer QANColTestList(Draw_Interpretor& di, Standard_Integer ar
return 0;
}
//=======================================================================
//function : QANColTestSet
//purpose :
//=======================================================================
static Standard_Integer QANColTestSet(Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
{
if ( argc != 1) {
di << "Usage : " << argv[0] << "\n";
return 1;
}
QANCollection_SetFunc aSet;
TestSet(aSet);
return 0;
}
//=======================================================================
//function : QANColTestSequence
//purpose :
@ -249,7 +233,6 @@ void QANCollection::Commands2(Draw_Interpretor& theCommands) {
theCommands.Add("QANColTestIndexedMap", "QANColTestIndexedMap", __FILE__, QANColTestIndexedMap, group);
theCommands.Add("QANColTestIndexedDataMap", "QANColTestIndexedDataMap", __FILE__, QANColTestIndexedDataMap, group);
theCommands.Add("QANColTestList", "QANColTestList", __FILE__, QANColTestList, group);
theCommands.Add("QANColTestSet", "QANColTestSet", __FILE__, QANColTestSet, group);
theCommands.Add("QANColTestSequence", "QANColTestSequence", __FILE__, QANColTestSequence, group);
return;

16
src/QANCollection/QANCollection3.cxx
View File

@ -28,7 +28,6 @@
IMPLEMENT_HARRAY1(QANCollection_HArray1Perf)
IMPLEMENT_HARRAY2(QANCollection_HArray2Perf)
IMPLEMENT_HSET(QANCollection_HSetPerf)
IMPLEMENT_HSEQUENCE(QANCollection_HSequencePerf)
//=======================================================================
@ -97,20 +96,6 @@ static Standard_Integer QANColPerfList(Draw_Interpretor& di, Standard_Integer ar
return 0;
}
//=======================================================================
//function : QANColPerfSet
//purpose :
//=======================================================================
static Standard_Integer QANColPerfSet(Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
{
Standard_Integer Repeat, Size;
if ( CheckArguments(di, argc, argv, Repeat, Size) ) {
return 1;
}
CompSet(Repeat,Size);
return 0;
}
//=======================================================================
//function : QANColPerfSequence
//purpose :
@ -216,7 +201,6 @@ void QANCollection::Commands3(Draw_Interpretor& theCommands) {
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("QANColPerfSet", "QANColPerfSet Repeat Size", __FILE__, QANColPerfSet, 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);

6
src/QANCollection/QANCollection_Common2.hxx
View File

@ -67,14 +67,8 @@ DEFINE_INDEXEDMAP(QANCollection_IndexedMapFunc,QANCollection_Key1BaseColFunc,Key
DEFINE_INDEXEDDATAMAP(QANCollection_IDMapFunc,QANCollection_BaseColFunc,Key1Type,ItemType)
#include <NCollection_DefineList.hxx>
#include <NCollection_DefineSet.hxx>
#include <NCollection_DefineHSet.hxx>
////////////////////////////////DEFINE_LIST(QANCollection_List,QANCollection_BaseCol,ItemType)
////////////////////////////////DEFINE_SET(QANCollection_Set,QANCollection_Key2BaseCol,Key2Type)
////////////////////////////////DEFINE_HSET(QANCollection_HSet,QANCollection_Set)
DEFINE_LIST(QANCollection_ListFunc,QANCollection_BaseColFunc,ItemType)
DEFINE_SET(QANCollection_SetFunc,QANCollection_Key2BaseColFunc,Key2Type)
DEFINE_HSET(QANCollection_HSetFunc,QANCollection_SetFunc)
#include <NCollection_DefineSequence.hxx>
#include <NCollection_DefineHSequence.hxx>

6
src/QANCollection/QANCollection_Common3.hxx
View File

@ -67,14 +67,8 @@ DEFINE_INDEXEDMAP(QANCollection_IndexedMapPerf,QANCollection_Key1BaseColPerf,Key
DEFINE_INDEXEDDATAMAP(QANCollection_IDMapPerf,QANCollection_BaseColPerf,Key1Type,ItemType)
#include <NCollection_DefineList.hxx>
#include <NCollection_DefineSet.hxx>
#include <NCollection_DefineHSet.hxx>
////////////////////////////////DEFINE_LIST(QANCollection_List,QANCollection_BaseCol,ItemType)
////////////////////////////////DEFINE_SET(QANCollection_Set,QANCollection_Key2BaseCol,Key2Type)
////////////////////////////////DEFINE_HSET(QANCollection_HSet,QANCollection_Set)
DEFINE_LIST(QANCollection_ListPerf,QANCollection_BaseColPerf,ItemType)
DEFINE_SET(QANCollection_SetPerf,QANCollection_Key2BaseColPerf,Key2Type)
DEFINE_HSET(QANCollection_HSetPerf,QANCollection_SetPerf)
#include <NCollection_DefineSequence.hxx>
#include <NCollection_DefineHSequence.hxx>

52
src/QANCollection/QANCollection_FuncLists.hxx
View File

@ -70,58 +70,6 @@ void TestList (QANCollection_ListFunc& theL)
aL.Clear();
}
// ===================== Test methods of Set type =============================
////////////////////////////////void TestSet (QANCollection_Set& theS)
void TestSet (QANCollection_SetFunc& theS)
{
// Extent
Standard_Integer iExt=theS.Extent();
Standard_Integer i;
printf ("Info: testing Set(%d)\n", iExt);
Key2Type anItem;
// Constructor, Add
////////////////////////////////QANCollection_Set aSet1, aSet2, aSet;
QANCollection_SetFunc aSet1, aSet2, aSet;
for (i=1; i<=8; i++)
{
Random(anItem);
aSet1.Add(anItem);
if (i>4)
aSet2.Add(anItem);
}
for (i=1; i<=4; i++)
{
Random(anItem);
aSet2.Add(anItem);
}
if (!aSet2.Contains(anItem))
printf ("Error : set sais it does not contain its item\n");
// operator=, Union, Difference, Intersection
aSet = aSet1;
printCollection(aSet2,"Set2");
aSet1.Union(aSet2);
printCollection(aSet1,"Union");
if (!aSet1.IsAProperSubset(aSet2))
printf ("Error : not a proper subset?\n");
if (!aSet1.IsAProperSubset(aSet2))
printf ("Error : not a subset?!\n");
aSet1.Intersection(aSet);
printCollection(aSet,"Intersection");
aSet1.Difference(aSet2);
printCollection(aSet1,"Difference");
// operator=
////////////////////////////////Handle(QANCollection_HSet) aHS = new QANCollection_HSet(aSet);
Handle(QANCollection_HSetFunc) aHS = new QANCollection_HSetFunc(aSet);
// Assign
AssignCollection (aHS->ChangeSet(), theS);
// Clear
aSet.Clear();
}
// ===================== Test methods of Sequence type ========================
////////////////////////////////void TestSequence (QANCollection_Sequence& theS)
void TestSequence (QANCollection_SequenceFunc& theS)

1
src/QANCollection/QANCollection_FuncTest.hxx
View File

@ -34,7 +34,6 @@
// Standard_EXPORT void TestInDaMap (QANCollection_IDMap& theNM);
#include <QANCollection_FuncMaps.hxx>
// Standard_EXPORT void TestList (QANCollection_List& theLi);
// Standard_EXPORT void TestSet (QANCollection_Set& theSe);
// Standard_EXPORT void TestSequence(QANCollection_Sequence& theSq);
#include <QANCollection_FuncLists.hxx>

93
src/QANCollection/QANCollection_PerfLists.hxx
View File

@ -18,7 +18,6 @@
#include <QANCollection_ListOfPnt.hxx>
#include <TColgp_SequenceOfPnt.hxx>
#include <TColStd_SetOfInteger.hxx>
// ===================== Test perform of List type ==========================
void CompList (const Standard_Integer theRep,
@ -92,98 +91,6 @@ void CompList (const Standard_Integer theRep,
}
// ===================== Test perform of Set type ==========================
void CompSet (const Standard_Integer theRep,
const Standard_Integer theSize)
{
Standard_Integer i,j;
////////////////////////////////Perf_Meter aNPush ("NCollection_Set pushing",0);
////////////////////////////////Perf_Meter aTPush ("TCollection_Set pushing",0);
////////////////////////////////Perf_Meter aNFind ("NCollection_Set finding",0);
////////////////////////////////Perf_Meter aTFind ("TCollection_Set finding",0);
////////////////////////////////Perf_Meter aNOper ("NCollection_Set operator=",0);
////////////////////////////////Perf_Meter aTOper ("TCollection_Set operator=",0);
////////////////////////////////Perf_Meter aNClea ("NCollection_Set clearing",0);
////////////////////////////////Perf_Meter aTClea ("TCollection_Set clearing",0);
////////////////////////////////Perf_Meter aNAssi ("NCollection_Set Assign",0);
for (i=0; i<theRep; i++)
{
////////////////////////////////QANCollection_Set a1, a2;
QANCollection_SetPerf a1, a2;
////////////////////////////////aNPush.Start();
PERF_START_METER("NCollection_Set pushing")
for (j=1; j<=theSize; j++)
{
Key2Type anItem;
Random(anItem);
a1.Add(anItem);
}
////////////////////////////////aNPush.Stop();
PERF_STOP_METER("NCollection_Set pushing")
////////////////////////////////aNFind.Start();
PERF_START_METER("NCollection_Set finding")
for (j=1; j<=theSize; j++)
{
Key2Type anItem;
Random(anItem);
a1.Contains(anItem);
}
////////////////////////////////aNFind.Stop();
PERF_STOP_METER("NCollection_Set finding")
////////////////////////////////aNOper.Start();
PERF_START_METER("NCollection_Set operator=")
a2 = a1;
////////////////////////////////aNOper.Stop();
PERF_STOP_METER("NCollection_Set operator=")
////////////////////////////////aNAssi.Start();
PERF_START_METER("NCollection_Set Assign")
a2.Assign(a1);
////////////////////////////////aNAssi.Stop();
PERF_STOP_METER("NCollection_Set Assign")
////////////////////////////////aNClea.Start();
PERF_START_METER("NCollection_Set clearing")
a2.Clear();
////////////////////////////////aNClea.Stop();
PERF_STOP_METER("NCollection_Set clearing")
}
for (i=0; i<theRep; i++)
{
TColStd_SetOfInteger a1, a2;
////////////////////////////////aTPush.Start();
PERF_START_METER("TCollection_Set pushing")
for (j=1; j<=theSize; j++)
{
Key2Type anItem;
Random(anItem);
a1.Add(anItem);
}
////////////////////////////////aTPush.Stop();
PERF_STOP_METER("TCollection_Set pushing")
////////////////////////////////aTFind.Start();
PERF_START_METER("TCollection_Set finding")
for (j=1; j<=theSize; j++)
{
Key2Type anItem;
Random(anItem);
a1.Contains(anItem);
}
////////////////////////////////aTFind.Stop();
PERF_STOP_METER("TCollection_Set finding")
////////////////////////////////aTOper.Start();
PERF_START_METER("TCollection_Set operator=")
a2 = a1;
////////////////////////////////aTOper.Stop();
PERF_STOP_METER("TCollection_Set operator=")
////////////////////////////////aTClea.Start();
PERF_START_METER("TCollection_Set clearing")
a2.Clear();
////////////////////////////////aTClea.Stop();
PERF_STOP_METER("TCollection_Set clearing")
}
PERF_PRINT_ALL
}
// ===================== Test perform of Sequence type ==========================
void CompSequence (const Standard_Integer theRep,

19
src/TColStd/TColStd.cdl
View File

@ -143,25 +143,6 @@ class HSequenceOfTransient instantiates
HSequence from TCollection (Transient,
SequenceOfTransient from TColStd);
class SetOfInteger instantiates
Set from TCollection (Integer);
class SetOfReal instantiates
Set from TCollection (Real);
class SetOfTransient instantiates
Set from TCollection (Transient);
class HSetOfInteger instantiates
HSet from TCollection (Integer,
SetOfInteger from TColStd);
class HSetOfReal instantiates
HSet from TCollection (Real,
SetOfReal from TColStd);
class HSetOfTransient instantiates
HSet from TCollection (Transient,
SetOfTransient from TColStd);
--
-- Instantiations List (Integer,Real,Transient)
-- ********************************************

7
src/TCollection/TCollection.cdl
View File

@ -21,7 +21,6 @@
-- Updated R.LEQUETTE Jan 1993
-- Adding of modifying classes
-- - Sequence, HSequence
-- - Set, HSet
-- - List
-- - BasicMap, BasicMapIterator
-- - Map, DataMap, DoubleMap, IndexedMap, IndexedDataMap
@ -63,12 +62,6 @@ is
generic class HSequence;
---Purpose: An indexed double list handle by reference.
generic class Set, SetIterator, SetList;
---Purpose: A small set handled by value.
generic class HSet;
---Purpose: A small set handled by reference.
generic class MapHasher;
---Purpose: A Tool to instantiate Maps. Providing HashCode and
-- Comparisons on Keys.

155
src/TCollection/TCollection_HSet.cdl
View File

@ -1,155 +0,0 @@
-- Created on: 1993-03-02
-- Created by: Remi LEQUETTE
-- Copyright (c) 1993-1999 Matra Datavision
-- Copyright (c) 1999-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.
generic class HSet from TCollection
(Item as any;
TheSet as any) -- as Set from TCollection(Item))
inherits TShared from MMgt
---Purpose: An HSet is a collection of non-ordered items without any
-- duplicates. At each transaction, the system checks there are no duplicates.
-- HSet objects are handles to sets.
-- HSet is a generic class which depends on two parameters:
-- - Item, the type of element in the set,
-- - Set, the actual type of set handled by HSet. This is an
-- instantiation with TCollection_Set generic class.
is
Create returns mutable HSet from TCollection;
---Purpose: Construction of an empty set.
Extent(me) returns Integer from Standard
---Level: Public
---Purpose: Returns the number of items in the set me.
---C++: inline
is static;
IsEmpty(me) returns Boolean from Standard
---Level: Public
---Purpose: Returns True if the set <me> is empty, Extent == 0.
---C++: inline
is static;
Clear(me : mutable)
---Level: Public
---Purpose: Removes all the items from the set.
---C++: inline
is static;
Add(me : mutable; T : Item) returns Boolean from Standard
---Level: Public
---Purpose: Adds <T> to the set if this item does not
-- already exist. Returns False if <T> was
-- already in the set.
---Example:
-- before
-- me = {a,b,c,d}, T = y
-- after
-- me = {a,b,c,d,y} returns True
---C++: inline
is static;
Remove(me : mutable; T : Item) returns Boolean from Standard
---Level: Public
---Purpose: Removes <T> from the set and returns True.
-- Returns False if <T> was not in the set.
---Example:
-- before
-- me = {a,b,c,d}, T = a
-- after
-- me = {b,c,d} returns True
---C++: inline
is static;
Union(me; B : HSet from TCollection)
returns mutable HSet from TCollection
---Purpose: creation of a set containing all the items
-- of the set <me> and all the items of the set B
-- which are not in <me>.
---Example:
-- before
-- me = {a,b,c}, B = {d,a,f}
-- after
-- me = {a,b,c}, B = {d,a,f}
-- returns
-- {a,b,c,d,f}
is static;
Intersection(me; B : HSet from TCollection)
returns mutable HSet from TCollection
---Level: Public
---Purpose: Creation of a set containing all the
-- items which are both in the set <me> and in the set B
---Example:
-- before
-- me = {a,b,c}, B = {d,a,f}
-- after
-- me = {a,b,c}, B = {d,a,f}
-- returns
-- {a}
is static;
Difference(me; B: HSet from TCollection)
returns mutable HSet from TCollection
---Purpose: Compares set B with this set and deletes duplicates.
--Example:
-- before
-- me = {a,b,c}, B = {d,a,f}
-- after
-- me = {a,b,c}, B = {d,a,f}
-- returns
-- {b,c}
is static;
Contains(me; T : Item) returns Boolean from Standard
---Purpose: Returns True if an item is in the set me.
---C++: inline
is static;
IsASubset(me; S : HSet from TCollection) returns Boolean from Standard
---Purpose: Returns True if a set is contained in the set me.
-- The two sets can be identical.
---C++: inline
is static;
IsAProperSubset(me; S : HSet from TCollection)
returns Boolean from Standard
---Purpose: Returns True S is a subset and if all its elements are strictly included in this set.
-- The two sets cannot be identical.
---C++: inline
is static;
Set(me) returns TheSet
---Level: Advanced
---Purpose: Returns the internal set. For implementation.
---C++: inline
---C++: return const &
is static;
ChangeSet(me : mutable) returns TheSet
---Level: Advanced
---Purpose: Returns the internal set. For implementation.
---C++: inline
---C++: return &
is static;
fields
mySet : TheSet;
end HSet from TCollection;

84
src/TCollection/TCollection_HSet.gxx
View File

@ -1,84 +0,0 @@
// Created on: 1993-03-03
// Created by: Remi LEQUETTE
// Copyright (c) 1993-1999 Matra Datavision
// Copyright (c) 1999-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.
//=======================================================================
//function : TCollection_HSet
//purpose :
//=======================================================================
TCollection_HSet::TCollection_HSet()
{
}
//=======================================================================
//function : Union
//purpose :
//=======================================================================
Handle(TCollection_HSet) TCollection_HSet::Union
(const Handle(TCollection_HSet)& B) const
{
Handle(TCollection_HSet) R = new TCollection_HSet();
R->ChangeSet() = mySet;
R->ChangeSet().Union(B->Set());
return R;
}
//=======================================================================
//function : Intersection
//purpose :
//=======================================================================
Handle(TCollection_HSet) TCollection_HSet::Intersection
(const Handle(TCollection_HSet)& B) const
{
Handle(TCollection_HSet) R = new TCollection_HSet();
R->ChangeSet() = mySet;
R->ChangeSet().Intersection(B->Set());
return R;
}
//=======================================================================
//function : Difference
//purpose :
//=======================================================================
Handle(TCollection_HSet) TCollection_HSet::Difference
(const Handle(TCollection_HSet)& B) const
{
Handle(TCollection_HSet) R = new TCollection_HSet();
R->ChangeSet() = mySet;
R->ChangeSet().Difference(B->Set());
return R;
}
//=======================================================================
//function : IsSameState
//purpose :
//=======================================================================
//Standard_Boolean TCollection_HSet::IsSameState
// (const Handle(TCollection_HSet)& Other) const
//{
// Handle(TCollection_HSet) S = Handle(TCollection_HSet)::DownCast(Other);
// Standard_Boolean result = Standard_False;
// if (!S.IsNull()) {
// if (S->Extent() == Extent()) {
// result = IsASubset(S);
// }
// }
// return result;
//}

117
src/TCollection/TCollection_HSet.lxx
View File

@ -1,117 +0,0 @@
// Created on: 1993-03-02
// Created by: Remi LEQUETTE
// Copyright (c) 1993-1999 Matra Datavision
// Copyright (c) 1999-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.
//=======================================================================
//function : Extent
//purpose :
//=======================================================================
inline Standard_Integer TCollection_HSet::Extent() const
{
return mySet.Extent();
}
//=======================================================================
//function : IsEmpty
//purpose :
//=======================================================================
inline Standard_Boolean TCollection_HSet::IsEmpty() const
{
return mySet.IsEmpty();
}
//=======================================================================
//function : Clear
//purpose :
//=======================================================================
inline void TCollection_HSet::Clear()
{
mySet.Clear();
}
//=======================================================================
//function : Add
//purpose :
//=======================================================================
inline Standard_Boolean TCollection_HSet::Add(const Item& T)
{
return mySet.Add(T);
}
//=======================================================================
//function : Remove
//purpose :
//=======================================================================
inline Standard_Boolean TCollection_HSet::Remove(const Item& T)
{
return mySet.Remove(T);
}
//=======================================================================
//function : Contains
//purpose :
//=======================================================================
inline Standard_Boolean TCollection_HSet::Contains(const Item& T) const
{
return mySet.Contains(T);
}
//=======================================================================
//function : IsASubset
//purpose :
//=======================================================================
inline Standard_Boolean TCollection_HSet::IsASubset
(const Handle(TCollection_HSet)& S) const
{
return mySet.IsASubset(S->Set());
}
//=======================================================================
//function : IsAProperSubset
//purpose :
//=======================================================================
inline Standard_Boolean TCollection_HSet::IsAProperSubset
(const Handle(TCollection_HSet)& S) const
{
return mySet.IsAProperSubset(S->Set());
}
//=======================================================================
//function : Set
//purpose :
//=======================================================================
inline const TheSet& TCollection_HSet::Set() const
{
return mySet;
}
//=======================================================================
//function : ChangeSet
//purpose :
//=======================================================================
inline TheSet& TCollection_HSet::ChangeSet()
{
return mySet;
}

190
src/TCollection/TCollection_Set.cdl
View File

@ -1,190 +0,0 @@
-- Created on: 1993-03-02
-- Created by: Remi LEQUETTE
-- Copyright (c) 1993-1999 Matra Datavision
-- Copyright (c) 1999-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.
generic class Set from TCollection (Item as any)
---Purpose: A set is an unordered collection of items without
-- duplications. To test for duplications the operators == and !=
-- are used on the items.
-- Use a SetIterator to explore a Set.
-- Warning
-- A set generates the same result as a map. A map is
-- more effective; therefore it is advisable to use maps instead of sets.
-- Set is a generic class which consists of Items, types of elements in a set.
raises
NoSuchObject from Standard
private class SetList instantiates List from TCollection(Item);
class SetIterator from TCollection
---Purpose: Functions used for iterating the contents of a Set.
-- Note: an iterator class is automatically instantiated from
-- this generic class at the time of instantiation of a Set.
-- Warning
-- - A set is a non-ordered data structure. The order in
-- which entries of a set are explored by the iterator
-- depends on its contents, and changes when the set is edited.
-- - It is not recommended to modify the contents of a set
-- during iteration: the result is unpredictable.
raises NoSuchObject from Standard
is
Create returns SetIterator from TCollection;
---Purpose: Creates an empty iterator for a Set;
-- use the function Initialize to define the set to explore;.
Create(S : Set from TCollection) returns SetIterator from TCollection;
---Purpose: Creates an iterator on the set <S>.
Initialize(me : in out; S : Set from TCollection)
---Purpose: Sets or resets the iterator on the set <S>.
is static;
More(me) returns Boolean from Standard
---Purpose: Returns True if there are other items.
---C++: inline
is static;
Next(me: in out)
---Purpose: Positions the iterator to the next item.
---C++: inline
is static;
Value(me) returns any Item
raises NoSuchObject from Standard
---Purpose: Returns the item value corresponding to the
-- current position of the iterator.
---C++: return const &
---C++: inline
is static;
fields
myIterator : ListIteratorOfSetList;
end SetIterator from TCollection;
is
Create returns Set from TCollection;
---Purpose: Creation of an empty set.
Create(Other : Set from TCollection)
returns Set from TCollection
is private;
---Purpose: Creates by copying an existing Set.
-- Warning: Prints a message when other is not empty. It is
-- recommanded to use Assign (operator =).
Extent(me) returns Integer from Standard
---Level: Public
---Purpose: Returns the number of items in the set.
---C++: inline
is static;
IsEmpty(me) returns Boolean from Standard
---Level: Public
---Purpose: Returns True if the set is empty. i.e.
-- Extent() == 0.
---C++: inline
is static;
Clear(me : in out)
---Level: Public
---Purpose: Removes all items from the set.
---C++: inline
is static;
Add(me : in out; T : Item) returns Boolean from Standard
---Level: Public
---Purpose: Adds the item <T> in the set if it does not
-- already exist.Returns False if the item T already exists.
-- Example:
-- before
-- me = {a,b,c,d}, T = y
-- after
-- me = {a,b,c,d,y} returns True
is static;
Remove(me : in out; T : Item) returns Boolean from Standard
---Level: Public
---Purpose: Removes the item <T> from the set. Returns True if
-- the item was in the set.
-- Example:
-- before
-- me = {a,b,c,d}, T = a
-- after
-- me = {b,c,d} returns True
is static;
Union(me : in out; B : Set from TCollection)
---Level: Public
---Purpose: Add to <me> all the items of the set <B>
-- which are not in <me>.
-- Example:
-- before
-- me = {a,b,c}, B = {d,a,f}
-- after
-- me = {a,b,c,d,f}, B = {d,a,f}
is static;
Intersection(me : in out; B : Set from TCollection)
---Level: Public
---Purpose: Removes from <me> all the items which are not in <B>.
-- Example:
-- before
-- me = {a,b,c}, B = {d,a,f}
-- after
-- me = {a}, B = {d,a,f}
is static;
Difference(me : in out; B: Set from TCollection)
---Level: Public
---Purpose: Removes from <me> all the items which are in <B>.
-- Example:
-- before
-- me = {a,b,c}, B = {d,a,f}
-- after
-- me = {b,c}, B = {d,a,f}
is static;
Contains(me; T : Item) returns Boolean from Standard
---Level: Public
---Purpose: Returns True if the item <T> is in the set.
is static;
IsASubset(me; S : Set from TCollection) returns Boolean from Standard
---Level: Public
---Purpose: returns True if <S> is a subset of <me>. i.e. all
-- elements of <S> are in <me>.
is static;
IsAProperSubset(me; S : Set from TCollection)
returns Boolean from Standard
---Level: Public
---Purpose: returns True if <S> is strictly contained in <me>.
-- i.e <S> is a subset and its extent is not equal to
-- the extent of <me>.
is static;
fields
myItems : SetList;
friends
class SetIterator from TCollection
end Set from TCollection;

174
src/TCollection/TCollection_Set.gxx
View File

@ -1,174 +0,0 @@
// Created on: 1993-03-02
// Created by: Remi LEQUETTE
// Copyright (c) 1993-1999 Matra Datavision
// Copyright (c) 1999-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.
//=======================================================================
//function : TCollection_Set
//purpose :
//=======================================================================
TCollection_Set::TCollection_Set()
{
}
//=======================================================================
//function : TCollection_Set
//purpose :
//=======================================================================
TCollection_Set::TCollection_Set(const TCollection_Set& )
{
}
//=======================================================================
//function : Add
//purpose :
//=======================================================================
Standard_Boolean TCollection_Set::Add(const Item& T)
{
if (Contains(T))
return Standard_False;
else {
myItems.Prepend(T);
return Standard_True;
}
}
//=======================================================================
//function : Remove
//purpose :
//=======================================================================
Standard_Boolean TCollection_Set::Remove(const Item& T)
{
TCollection_ListIteratorOfSetList It(myItems);
while (It.More()) {
if (It.Value() == T) {
myItems.Remove(It);
return Standard_True;
}
It.Next();
}
return Standard_False;
}
//=======================================================================
//function : Union
//purpose :
//=======================================================================
void TCollection_Set::Union(const TCollection_Set& B)
{
Standard_Integer N = Extent();
Standard_Integer i;
TCollection_ListIteratorOfSetList It1,It2;
// for each item in B
for (It1.Initialize(B.myItems); It1.More(); It1.Next()) {
// test with the N first items of me
// because the other ones are imported from B
It2.Initialize(myItems);
Standard_Boolean found = Standard_False;
for (i = 1; i <= N; i++) {
if (It1.Value() == It2.Value()) {
found = Standard_True;
break;
}
It2.Next();
}
if (!found)
myItems.Append(It1.Value());
}
}
//=======================================================================
//function : Intersection
//purpose :
//=======================================================================
void TCollection_Set::Intersection(const TCollection_Set& B)
{
TCollection_ListIteratorOfSetList It(myItems);
while (It.More()) {
if (B.Contains(It.Value()))
It.Next();
else
myItems.Remove(It);
}
}
//=======================================================================
//function : Difference
//purpose :
//=======================================================================
void TCollection_Set::Difference(const TCollection_Set& B)
{
TCollection_ListIteratorOfSetList It(myItems);
while (It.More()) {
if (B.Contains(It.Value()))
myItems.Remove(It);
else
It.Next();
}
}
//=======================================================================
//function : Contains
//purpose :
//=======================================================================
Standard_Boolean TCollection_Set::Contains(const Item& T) const
{
TCollection_ListIteratorOfSetList It(myItems);
while (It.More()) {
if (It.Value() == T) return Standard_True;
It.Next();
}
return Standard_False;
}
//=======================================================================
//function : IsASubset
//purpose :
//=======================================================================
Standard_Boolean TCollection_Set::IsASubset(const TCollection_Set& S) const
{
if (S.Extent() > Extent()) return Standard_False;
TCollection_ListIteratorOfSetList It(S.myItems);
while (It.More()) {
if (!Contains(It.Value())) return Standard_False;
It.Next();
}
return Standard_True;
}
//=======================================================================
//function : IsAProperSubset
//purpose :
//=======================================================================
Standard_Boolean TCollection_Set::IsAProperSubset
(const TCollection_Set& S) const
{
if (S.Extent() >= Extent()) return Standard_False;
return IsASubset(S);
}

46
src/TCollection/TCollection_Set.lxx
View File

@ -1,46 +0,0 @@
// Created on: 1993-03-02
// Created by: Remi LEQUETTE
// Copyright (c) 1993-1999 Matra Datavision
// Copyright (c) 1999-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.
//=======================================================================
//function : Extent
//purpose :
//=======================================================================
inline Standard_Integer TCollection_Set::Extent() const
{
return myItems.Extent();
}
//=======================================================================
//function : IsEmpty
//purpose :
//=======================================================================
inline Standard_Boolean TCollection_Set::IsEmpty() const
{
return myItems.IsEmpty();
}
//=======================================================================
//function : Clear
//purpose :
//=======================================================================
inline void TCollection_Set::Clear()
{
myItems.Clear();
}

46
src/TCollection/TCollection_SetIterator.gxx
View File

@ -1,46 +0,0 @@
// Created on: 1993-03-03
// Created by: Remi LEQUETTE
// Copyright (c) 1993-1999 Matra Datavision
// Copyright (c) 1999-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.
//=======================================================================
//function : TCollection_SetIterator
//purpose :
//=======================================================================
TCollection_SetIterator::TCollection_SetIterator()
{
}
//=======================================================================
//function : TCollection_SetIterator
//purpose :
//=======================================================================
TCollection_SetIterator::TCollection_SetIterator(const TCollection_Set& S)
{
Initialize(S);
}
//=======================================================================
//function : Initialize
//purpose :
//=======================================================================
void TCollection_SetIterator::Initialize(const TCollection_Set& S)
{
myIterator.Initialize(S.myItems);
}

45
src/TCollection/TCollection_SetIterator.lxx
View File

@ -1,45 +0,0 @@
// Created on: 1993-03-02
// Created by: Remi LEQUETTE
// Copyright (c) 1993-1999 Matra Datavision
// Copyright (c) 1999-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.
//=======================================================================
//function : More
//purpose :
//=======================================================================
inline Standard_Boolean TCollection_SetIterator::More() const
{
return myIterator.More();
}
//=======================================================================
//function : Next
//purpose :
//=======================================================================
inline void TCollection_SetIterator::Next()
{
myIterator.Next();
}
//=======================================================================
//function : Value
//purpose :
//=======================================================================
inline const Item& TCollection_SetIterator::Value() const
{
return myIterator.Value();
}

2
src/V3d/V3d.cxx
View File

@ -41,8 +41,6 @@
#include <Graphic3d_Structure.hxx>
#include <Graphic3d_AspectLine3d.hxx>
#include <Graphic3d_AspectText3d.hxx>
#include <Visual3d_HSetOfView.hxx>
#include <Visual3d_SetIteratorOfSetOfView.hxx>
#include <Visual3d_View.hxx>
#include <Visual3d_ViewManager.hxx>

18
src/Visual3d/Visual3d.cdl
View File

@ -268,22 +268,20 @@ is
imported NListOfLayerItem;
class SetOfLight instantiates
Set from TCollection (Light from Visual3d);
class SequenceOfLight instantiates
Sequence from TCollection (Light from Visual3d);
---Category: Instantiated classes
class HSetOfLight instantiates
HSet from TCollection
(Light from Visual3d, SetOfLight);
class HSequenceOfLight instantiates
HSequence from TCollection (Light from Visual3d, SequenceOfLight);
---Category: Instantiated classes
class SetOfView instantiates
Set from TCollection (View from Visual3d);
class SequenceOfView instantiates
Sequence from TCollection (View from Visual3d);
---Category: Instantiated classes
class HSetOfView instantiates
HSet from TCollection
(View from Visual3d, SetOfView);
class HSequenceOfView instantiates
HSequence from TCollection (View from Visual3d, SequenceOfView);
---Category: Instantiated classes
end Visual3d;

4
src/Visual3d/Visual3d_ContextView.cdl
View File

@ -36,7 +36,7 @@ uses
SequenceOfAddress from TColStd,
Light from Visual3d,
HSetOfLight from Visual3d,
HSequenceOfLight from Visual3d,
TypeOfModel from Visual3d,
TypeOfVisualization from Visual3d,
TypeOfSurfaceDetail from Visual3d,
@ -277,7 +277,7 @@ is
----------------------------
ActivatedLights ( me )
returns HSetOfLight from Visual3d
returns HSequenceOfLight from Visual3d
is static;
---Level: Internal
---Purpose: Returns the group of active light sources

6
src/Visual3d/Visual3d_ContextView.cxx
View File

@ -281,13 +281,13 @@ Standard_Integer indexL = 0;
}
Handle(Visual3d_HSetOfLight) Visual3d_ContextView::ActivatedLights () const {
Handle(Visual3d_HSequenceOfLight) Visual3d_ContextView::ActivatedLights () const {
Handle(Visual3d_HSetOfLight) SG = new Visual3d_HSetOfLight ();
Handle(Visual3d_HSequenceOfLight) SG = new Visual3d_HSequenceOfLight();
Standard_Integer Length = MyLights.Length ();
for (Standard_Integer i=1; i<=Length; i++)
SG->Add ((Visual3d_Light *) (MyLights.Value (i)));
SG->Append((Visual3d_Light *) (MyLights.Value (i)));
return (SG);

2
src/Visual3d/Visual3d_View.cdl
View File

@ -91,7 +91,7 @@ uses
ContextView from Visual3d,
Layer from Visual3d,
Light from Visual3d,
SetOfLight from Visual3d,
SequenceOfLight from Visual3d,
TypeOfAnswer from Visual3d,
ViewManager from Visual3d,
ViewManagerPtr from Visual3d,

15
src/Visual3d/Visual3d_View.cxx
View File

@ -134,11 +134,7 @@
#include <Graphic3d_Vertex.hxx>
#include <Visual3d_Light.hxx>
#include <Visual3d_SetOfLight.hxx>
#include <Visual3d_HSetOfLight.hxx>
#include <Visual3d_HSetOfView.hxx>
#include <Visual3d_SetIteratorOfSetOfLight.hxx>
#include <Visual3d_SetIteratorOfSetOfView.hxx>
#include <Visual3d_HSequenceOfView.hxx>
#include <Graphic3d_TextureEnv.hxx>
@ -1306,12 +1302,13 @@ Standard_Boolean Visual3d_View::DisplayImmediate (const Handle(Graphic3d_Structu
if (theIsSingleView)
{
Handle(Visual3d_HSetOfView) aViews = MyViewManager->DefinedView();
for (Visual3d_SetIteratorOfSetOfView aViewIter (aViews->Set()); aViewIter.More(); aViewIter.Next())
Handle(Visual3d_HSequenceOfView) aViews = MyViewManager->DefinedView();
for (int i=1;i<=aViews->Length();i++)
{
if (aViewIter.Value().Access() != this)
if (aViews->Value(i).Access() != this)
{
aViewIter.Value()->EraseImmediate (theStructure);
aViews->Value(i)->EraseImmediate (theStructure);
}
}
}

10
src/Visual3d/Visual3d_ViewManager.cdl
View File

@ -46,8 +46,8 @@ uses
ContextPick from Visual3d,
Layer from Visual3d,
SetOfView from Visual3d,
HSetOfView from Visual3d,
SequenceOfView from Visual3d,
HSequenceOfView from Visual3d,
View from Visual3d
is
@ -123,14 +123,14 @@ is
----------------------------
ActivatedView ( me )
returns HSetOfView from Visual3d
returns HSequenceOfView from Visual3d
is static;
---Level: Internal
---Purpose: Returns the group of views activated in the visualiser <me>.
---Category: Inquire methods
DefinedView ( me )
returns HSetOfView from Visual3d
returns HSequenceOfView from Visual3d
is static;
---Level: Internal
---Purpose: Returns the group of views defined in the visualiser <me>.
@ -459,7 +459,7 @@ fields
-- and a group of views.
--
-- the defined views
MyDefinedView : SetOfView from Visual3d;
MyDefinedView : SequenceOfView from Visual3d;
-- the layers
MyUnderLayer : Layer from Visual3d;

425
src/Visual3d/Visual3d_ViewManager.cxx
View File

@ -67,7 +67,6 @@
#include <Graphic3d_MapOfStructure.hxx>
#include <Graphic3d_MapIteratorOfMapOfStructure.hxx>
#include <Visual3d_SetIteratorOfSetOfView.hxx>
#if defined (_WIN32) || defined(__WIN32__)
# include <WNT_Window.hxx>
@ -82,7 +81,7 @@
//-Global data definitions
// -- les vues definies
// MyDefinedView : SetOfView;
// MyDefinedView : SequenceOfView;
// -- le generateur d'identificateurs de vues
// MyViewGenId : GenId;
@ -142,7 +141,8 @@ void Visual3d_ViewManager::Remove () {
MyDefinedView.Clear();
}
void Visual3d_ViewManager::ChangeDisplayPriority (const Handle(Graphic3d_Structure)& AStructure, const Standard_Integer OldPriority, const Standard_Integer NewPriority) {
void Visual3d_ViewManager::ChangeDisplayPriority (const Handle(Graphic3d_Structure)& AStructure, const Standard_Integer OldPriority, const Standard_Integer NewPriority)
{
#ifdef TRACE
cout << "Visual3d_ViewManager::ChangeDisplayPriority ("
@ -154,16 +154,10 @@ void Visual3d_ViewManager::ChangeDisplayPriority (const Handle(Graphic3d_Structu
//
// Change structure priority in all defined views
//
Visual3d_SetIteratorOfSetOfView MyIterator(MyDefinedView);
while (MyIterator.More ()) {
(MyIterator.Value ())->ChangeDisplayPriority
(AStructure, OldPriority, NewPriority);
// MyIterator.Next () is located on the next view
MyIterator.Next ();
for(int i=1; i<=MyDefinedView.Length(); i++)
{
(MyDefinedView.Value(i))->ChangeDisplayPriority(AStructure, OldPriority, NewPriority);
}
}
void Visual3d_ViewManager::ReCompute (const Handle(Graphic3d_Structure)& AStructure) {
@ -180,15 +174,10 @@ void Visual3d_ViewManager::ReCompute (const Handle(Graphic3d_Structure)& AStruct
//
// Recompute structure in all activated views
//
Visual3d_SetIteratorOfSetOfView MyIterator(MyDefinedView);
while (MyIterator.More ()) {
(MyIterator.Value ())->ReCompute (AStructure);
// MyIterator.Next () is located on the next view
MyIterator.Next ();
for(int i=1; i<=MyDefinedView.Length(); i++)
{
(MyDefinedView.Value(i))->ReCompute(AStructure);
}
}
void Visual3d_ViewManager::ReCompute (const Handle(Graphic3d_Structure)& AStructure,
@ -213,106 +202,71 @@ void Visual3d_ViewManager::ReCompute (const Handle(Graphic3d_Structure)& AStruct
//
// Recompute structure in all activated views
//
Visual3d_SetIteratorOfSetOfView MyIterator(MyDefinedView);
while (MyIterator.More ()) {
if ((MyIterator.Value ())->Identification () == ViewId)
for(int i=1; i<=MyDefinedView.Length(); i++)
{
if ((MyDefinedView.Value(i))->Identification () == ViewId)
{
theView->ReCompute (AStructure);
// MyIterator.Next () is located on the next view
MyIterator.Next ();
}
}
}
void Visual3d_ViewManager::Clear (const Handle(Graphic3d_Structure)& AStructure, const Standard_Boolean WithDestruction)
{
for(int i=1; i<=MyDefinedView.Length(); i++)
{
(MyDefinedView.Value(i))->Clear(AStructure, WithDestruction);
}
}
void Visual3d_ViewManager::Clear (const Handle(Graphic3d_Structure)& AStructure, const Standard_Boolean WithDestruction) {
Visual3d_SetIteratorOfSetOfView MyIterator(MyDefinedView);
while (MyIterator.More ()) {
(MyIterator.Value ())->Clear (AStructure, WithDestruction);
// MyIterator.Next () is located on the next view
MyIterator.Next ();
void Visual3d_ViewManager::Connect (const Handle(Graphic3d_Structure)& AMother, const Handle(Graphic3d_Structure)& ADaughter)
{
for(int i=1; i<=MyDefinedView.Length(); i++)
{
(MyDefinedView.Value(i))->Connect (AMother, ADaughter);
}
}
void Visual3d_ViewManager::Disconnect (const Handle(Graphic3d_Structure)& AMother, const Handle(Graphic3d_Structure)& ADaughter)
{
for(int i=1; i<=MyDefinedView.Length(); i++)
{
(MyDefinedView.Value(i))->Disconnect (AMother, ADaughter);
}
}
void Visual3d_ViewManager::Connect (const Handle(Graphic3d_Structure)& AMother, const Handle(Graphic3d_Structure)& ADaughter) {
Visual3d_SetIteratorOfSetOfView MyIterator(MyDefinedView);
while (MyIterator.More ()) {
(MyIterator.Value ())->Connect (AMother, ADaughter);
// MyIterator.Next () is located on the next view
MyIterator.Next ();
}
}
void Visual3d_ViewManager::Disconnect (const Handle(Graphic3d_Structure)& AMother, const Handle(Graphic3d_Structure)& ADaughter) {
Visual3d_SetIteratorOfSetOfView MyIterator(MyDefinedView);
while (MyIterator.More ()) {
(MyIterator.Value ())->Disconnect (AMother, ADaughter);
// MyIterator.Next () is located on the next view
MyIterator.Next ();
}
}
void Visual3d_ViewManager::Display (const Handle(Graphic3d_Structure)& AStructure) {
void Visual3d_ViewManager::Display (const Handle(Graphic3d_Structure)& AStructure)
{
// Even if physically the structure cannot
// be displayed (pb of visualisation type)
// it has status Displayed.
MyDisplayedStructure.Add(AStructure);
//
// Display structure in all activated views
//
Visual3d_SetIteratorOfSetOfView MyIterator(MyDefinedView);
while (MyIterator.More ()) {
(MyIterator.Value ())->Display (AStructure);
// MyIterator.Next () is located on the next view
MyIterator.Next ();
for(int i=1; i<=MyDefinedView.Length(); i++)
{
(MyDefinedView.Value(i))->Display(AStructure);
}
}
}
void Visual3d_ViewManager::Erase (const Handle(Graphic3d_Structure)& AStructure) {
void Visual3d_ViewManager::Erase (const Handle(Graphic3d_Structure)& AStructure)
{
// Even if physically the structure cannot
// be displayed (pb of visualisation type)
// it has status Displayed.
MyDisplayedStructure.Remove(AStructure);
//
// Erase structure in all defined views
//
Visual3d_SetIteratorOfSetOfView MyIterator(MyDefinedView);
while (MyIterator.More ()) {
(MyIterator.Value ())->Erase (AStructure);
// MyIterator.Next () is located on the next view
MyIterator.Next ();
for(int i=1; i<=MyDefinedView.Length(); i++)
{
(MyDefinedView.Value(i))->Erase (AStructure);
}
MyHighlightedStructure.Remove (AStructure);
MyPickStructure.Remove (AStructure);
}
void Visual3d_ViewManager::Erase () {
@ -326,35 +280,26 @@ void Visual3d_ViewManager::Erase () {
}
void Visual3d_ViewManager::Highlight (const Handle(Graphic3d_Structure)& AStructure, const Aspect_TypeOfHighlightMethod AMethod) {
void Visual3d_ViewManager::Highlight (const Handle(Graphic3d_Structure)& AStructure, const Aspect_TypeOfHighlightMethod AMethod)
{
MyHighlightedStructure.Add(AStructure);
//
// Highlight in all activated views
//
Visual3d_SetIteratorOfSetOfView MyIterator(MyDefinedView);
while (MyIterator.More ()) {
(MyIterator.Value ())->Highlight (AStructure, AMethod);
// MyIterator.Next () is located on the next view
MyIterator.Next ();
for(int i=1; i<=MyDefinedView.Length(); i++)
{
(MyDefinedView.Value(i))->Highlight (AStructure, AMethod);
}
}
void Visual3d_ViewManager::SetTransform (const Handle(Graphic3d_Structure)& AStructure, const TColStd_Array2OfReal& ATrsf)
{
for(int i=1; i<=MyDefinedView.Length(); i++)
{
(MyDefinedView.Value(i))->SetTransform (AStructure, ATrsf);
}
void Visual3d_ViewManager::SetTransform (const Handle(Graphic3d_Structure)& AStructure, const TColStd_Array2OfReal& ATrsf) {
Visual3d_SetIteratorOfSetOfView MyIterator(MyDefinedView);
while (MyIterator.More ()) {
(MyIterator.Value ())->SetTransform (AStructure, ATrsf);
// MyIterator.Next () is located on the next view
MyIterator.Next ();
}
}
void Visual3d_ViewManager::UnHighlight () {
@ -369,29 +314,24 @@ void Visual3d_ViewManager::UnHighlight () {
}
void Visual3d_ViewManager::UnHighlight (const Handle(Graphic3d_Structure)& AStructure) {
void Visual3d_ViewManager::UnHighlight (const Handle(Graphic3d_Structure)& AStructure)
{
MyHighlightedStructure.Remove(AStructure);
//
// UnHighlight in all activated views
//
Visual3d_SetIteratorOfSetOfView MyIterator(MyDefinedView);
while (MyIterator.More ()) {
(MyIterator.Value ())->UnHighlight (AStructure);
// MyIterator.Next () is located on the next view
MyIterator.Next ();
for(int i=1; i<=MyDefinedView.Length(); i++)
{
(MyDefinedView.Value(i))->UnHighlight (AStructure);
}
}
void Visual3d_ViewManager::Redraw() const
{
// redraw all activated views
if (MyDefinedView.Extent() == 0)
if (MyDefinedView.Length() == 0)
{
return;
}
@ -401,13 +341,14 @@ void Visual3d_ViewManager::Redraw() const
Standard_Integer aWidth = 0, aHeight = 0;
Standard_Integer aWidthMax = 0;
Standard_Integer aHeightMax = 0;
for (Visual3d_SetIteratorOfSetOfView anIter (MyDefinedView);
anIter.More(); anIter.Next())
for(int i=1; i<=MyDefinedView.Length(); i++)
{
anIter.Value()->Window()->Size (aWidth, aHeight);
MyDefinedView.Value(i)->Window()->Size (aWidth, aHeight);
aWidthMax = Max (aWidthMax, aWidth);
aHeightMax = Max (aHeightMax, aWidth);
}
if (!MyUnderLayer.IsNull())
{
MyUnderLayer->SetViewport (aWidthMax, aHeightMax);
@ -418,10 +359,9 @@ void Visual3d_ViewManager::Redraw() const
}
}
for (Visual3d_SetIteratorOfSetOfView anIter (MyDefinedView);
anIter.More(); anIter.Next())
for(int i=1; i<=MyDefinedView.Length(); i++)
{
anIter.Value()->Redraw (MyUnderLayer, MyOverLayer);
MyDefinedView.Value(i)->Redraw (MyUnderLayer, MyOverLayer);
}
}
@ -432,101 +372,86 @@ void Visual3d_ViewManager::Update() const
void Visual3d_ViewManager::RedrawImmediate() const
{
if (MyDefinedView.Extent() == 0)
if (MyDefinedView.Length() == 0)
{
return;
}
// update all activated views
for (Visual3d_SetIteratorOfSetOfView anIter (MyDefinedView);
anIter.More(); anIter.Next())
for(int i=1; i<=MyDefinedView.Length(); i++)
{
anIter.Value()->RedrawImmediate (MyUnderLayer, MyOverLayer);
MyDefinedView.Value(i)->RedrawImmediate (MyUnderLayer, MyOverLayer);
}
}
void Visual3d_ViewManager::Invalidate() const
{
if (MyDefinedView.Extent() == 0)
if (MyDefinedView.Length() == 0)
{
return;
}
// update all activated views
for (Visual3d_SetIteratorOfSetOfView anIter (MyDefinedView);
anIter.More(); anIter.Next())
for(int i=1; i<=MyDefinedView.Length(); i++)
{
anIter.Value()->Invalidate();
MyDefinedView.Value(i)->Invalidate();
}
}
Handle(Visual3d_HSetOfView) Visual3d_ViewManager::ActivatedView () const {
Handle(Visual3d_HSequenceOfView) Visual3d_ViewManager::ActivatedView () const
{
Handle (Visual3d_HSetOfView) SG = new Visual3d_HSetOfView ();
Handle(Visual3d_HSequenceOfView) SG = new Visual3d_HSequenceOfView();
Visual3d_SetIteratorOfSetOfView MyIterator(MyDefinedView);
while (MyIterator.More ()) {
if ((MyIterator.Value ())->IsActive ())
SG->Add (MyIterator.Value ());
// MyIterator.Next () is located on the next view
MyIterator.Next ();
for(int i=1; i<=MyDefinedView.Length(); i++)
{
if ((MyDefinedView.Value(i))->IsActive ())
{
SG->Append(MyDefinedView.Value(i));
}
}
return (SG);
}
#ifdef IMPLEMENTED
Standard_Boolean Visual3d_ViewManager::ContainsComputedStructure () const {
Standard_Boolean Visual3d_ViewManager::ContainsComputedStructure () const
{
Standard_Boolean Result = Standard_False;
//
// Check all activated views
//
Visual3d_SetIteratorOfSetOfView MyIterator(MyDefinedView);
Standard_Integer i = MyDefinedView.Extent ();
while ((! Result) && (MyIterator.More ())) {
if ((MyIterator.Value ())->IsActive ())
Result =
(MyIterator.Value ())->ContainsComputedStructure ();
// MyIterator.Next () is located on the next view
MyIterator.Next ();
for(int i=1; (!Result) && i<=MyDefinedView.Length(); i++)
{
if ((MyDefinedView.Value(i))->IsActive())
{
Result = (MyDefinedView.Value(i))->ContainsComputedStructure();
}
}
return Result;
}
#endif
Handle(Visual3d_HSetOfView) Visual3d_ViewManager::DefinedView () const {
Handle(Visual3d_HSequenceOfView) Visual3d_ViewManager::DefinedView () const
{
Handle (Visual3d_HSequenceOfView) SG = new Visual3d_HSequenceOfView();
Handle (Visual3d_HSetOfView) SG = new Visual3d_HSetOfView ();
Visual3d_SetIteratorOfSetOfView MyIterator(MyDefinedView);
while (MyIterator.More ()) {
SG->Add (MyIterator.Value ());
// MyIterator.Next () is located on the next view
MyIterator.Next ();
for(int i=1; i<=MyDefinedView.Length(); i++)
{
SG->Append(MyDefinedView.Value(i));
}
return (SG);
}
Standard_Boolean Visual3d_ViewManager::ViewExists (const Handle(Aspect_Window)& AWindow, Graphic3d_CView& TheCView) const {
Standard_Boolean Visual3d_ViewManager::ViewExists (const Handle(Aspect_Window)& AWindow, Graphic3d_CView& TheCView) const
{
Standard_Boolean Exist = Standard_False;
// Parse the list of views to find
// a view with the specified window
Visual3d_SetIteratorOfSetOfView MyIterator(MyDefinedView);
#if defined(_WIN32) || defined(__WIN32__)
const Handle(WNT_Window) THEWindow = Handle(WNT_Window)::DownCast (AWindow);
@ -539,12 +464,12 @@ Standard_Boolean Exist = Standard_False;
int TheSpecifiedWindowId = int (THEWindow->XWindow ());
#endif
while ((! Exist) && (MyIterator.More ())) {
for(int i=1; (!Exist) && i<=MyDefinedView.Length(); i++)
{
if ( ((MyDefinedView.Value(i))->IsDefined ()) && ((MyDefinedView.Value(i))->IsActive ()) )
{
const Handle(Aspect_Window) AspectWindow = (MyDefinedView.Value(i))->Window();
if ( ((MyIterator.Value ())->IsDefined ()) &&
((MyIterator.Value ())->IsActive ()) ) {
const Handle(Aspect_Window) AspectWindow = (MyIterator.Value ())->Window ();
#if defined(_WIN32) || defined(__WIN32__)
const Handle(WNT_Window) theWindow = Handle(WNT_Window)::DownCast (AspectWindow);
Aspect_Handle TheWindowIdOfView = theWindow->HWindow ();
@ -556,50 +481,42 @@ const Handle(Aspect_Window) AspectWindow = (MyIterator.Value ())->Window ();
int TheWindowIdOfView = int (theWindow->XWindow ());
#endif // WNT
// Comparaison on window IDs
if (TheWindowIdOfView == TheSpecifiedWindowId) {
if (TheWindowIdOfView == TheSpecifiedWindowId)
{
Exist = Standard_True;
TheCView = *(Graphic3d_CView* )(MyIterator.Value())->CView();
TheCView = *(Graphic3d_CView* )(MyDefinedView.Value(i))->CView();
}
}
} /* if ((MyIterator.Value ())->IsDefined ()) */
// MyIterator.Next () is located on the next view
MyIterator.Next ();
}
return (Exist);
}
void Visual3d_ViewManager::Activate () {
void Visual3d_ViewManager::Activate ()
{
//
// Activates all deactivated views
//
Visual3d_SetIteratorOfSetOfView MyIterator(MyDefinedView);
while (MyIterator.More ()) {
if (! (MyIterator.Value ())->IsActive ())
(MyIterator.Value ())->Activate ();
// MyIterator.Next () is located on the next view
MyIterator.Next ();
for(int i=1; i<=MyDefinedView.Length(); i++)
{
if (! (MyDefinedView.Value(i))->IsActive())
{
(MyDefinedView.Value(i))->Activate();
}
}
}
}
void Visual3d_ViewManager::Deactivate () {
void Visual3d_ViewManager::Deactivate ()
{
//
// Deactivates all activated views
//
Visual3d_SetIteratorOfSetOfView MyIterator(MyDefinedView);
while (MyIterator.More ()) {
if ((MyIterator.Value ())->IsActive ())
(MyIterator.Value ())->Deactivate ();
// MyIterator.Next () is located on the next view
MyIterator.Next ();
for(int i=1; i<=MyDefinedView.Length(); i++)
{
if ((MyDefinedView.Value(i))->IsActive())
{
(MyDefinedView.Value(i))->Deactivate();
}
}
}
@ -625,55 +542,47 @@ Standard_Integer Visual3d_ViewManager::Identification () const {
}
Standard_Integer Visual3d_ViewManager::Identification (const Handle(Visual3d_View)& AView) {
MyDefinedView.Add (AView);
Standard_Integer Visual3d_ViewManager::Identification (const Handle(Visual3d_View)& AView)
{
MyDefinedView.Append(AView);
return (MyViewGenId.Next ());
}
void Visual3d_ViewManager::UnIdentification (const Standard_Integer aViewId)
{
Visual3d_SetIteratorOfSetOfView MyIterator(MyDefinedView);
while (MyIterator.More())
for(int i=1; i<=MyDefinedView.Length(); i++)
{
if ((MyIterator.Value())->Identification () == aViewId)
if ((MyDefinedView.Value(i))->Identification() == aViewId)
{
const Handle(Visual3d_View)& theView = MyIterator.Value();
//remove the view from the list
MyDefinedView.Remove(theView);
MyDefinedView.Remove(i);
break;
}
// go to next
MyIterator.Next ();
}
MyViewGenId.Free(aViewId);
}
void Visual3d_ViewManager::SetTransparency (const Standard_Boolean AFlag) {
void Visual3d_ViewManager::SetTransparency (const Standard_Boolean AFlag)
{
if (MyTransparency && AFlag) return;
if (! MyTransparency && ! AFlag) return;
Visual3d_SetIteratorOfSetOfView MyIterator(MyDefinedView);
while (MyIterator.More ()) {
(MyIterator.Value ())->SetTransparency (AFlag);
// MyIterator.Next () is located on the next view
MyIterator.Next ();
for(int i=1; i<=MyDefinedView.Length(); i++)
{
(MyDefinedView.Value(i))->SetTransparency(AFlag);
}
MyTransparency = AFlag;
}
Standard_Boolean Visual3d_ViewManager::Transparency () const {
Standard_Boolean Visual3d_ViewManager::Transparency () const
{
return (MyTransparency);
}
void Visual3d_ViewManager::SetZBufferAuto (const Standard_Boolean AFlag) {
void Visual3d_ViewManager::SetZBufferAuto (const Standard_Boolean AFlag)
{
if (MyZBufferAuto && AFlag) return;
if (! MyZBufferAuto && ! AFlag) return;
@ -685,22 +594,19 @@ void Visual3d_ViewManager::SetZBufferAuto (const Standard_Boolean AFlag) {
// zbuffer could be active only if required by context.
// In this case -1 is passed so that the view ask itself the question
// Note : 0 forces the desactivation, 1 forces the activation
if (! AFlag) {
Visual3d_SetIteratorOfSetOfView MyIterator(MyDefinedView);
while (MyIterator.More ()) {
(MyIterator.Value ())->SetZBufferActivity (-1);
// MyIterator.Next () is located on the next view
MyIterator.Next ();
if (! AFlag)
{
for(int i=1; i<=MyDefinedView.Length(); i++)
{
(MyDefinedView.Value(i))->SetZBufferActivity(-1);
}
}
MyZBufferAuto = AFlag;
}
Standard_Boolean Visual3d_ViewManager::ZBufferAuto () const {
Standard_Boolean Visual3d_ViewManager::ZBufferAuto () const
{
return (MyZBufferAuto);
}
void Visual3d_ViewManager::SetLayer (const Handle(Visual3d_Layer)& ALayer) {
@ -756,9 +662,10 @@ void Visual3d_ViewManager::ChangeZLayer (const Handle(Graphic3d_Structure)& theS
// change display layer for structure in all views
if (MyDisplayedStructure.Contains (theStructure))
{
Visual3d_SetIteratorOfSetOfView aViewIt(MyDefinedView);
for ( ; aViewIt.More (); aViewIt.Next ())
(aViewIt.Value ())->ChangeZLayer (theStructure, theLayerId);
for(int i=1; i<=MyDefinedView.Length(); i++)
{
(MyDefinedView.Value(i))->ChangeZLayer(theStructure, theLayerId);
}
}
// tell graphic driver to update the structure's display layer
@ -783,10 +690,9 @@ void Visual3d_ViewManager::SetZLayerSettings (const Standard_Integer theLayerId,
const Graphic3d_ZLayerSettings& theSettings)
{
// tell all managed views to set zlayer settings
Visual3d_SetIteratorOfSetOfView aViewIt (MyDefinedView);
for (; aViewIt.More (); aViewIt.Next ())
for(int i=1; i<=MyDefinedView.Length(); i++)
{
(aViewIt.Value ())->SetZLayerSettings (theLayerId, theSettings);
(MyDefinedView.Value(i))->SetZLayerSettings (theLayerId, theSettings);
}
if (myMapOfZLayerSettings.IsBound (theLayerId))
@ -838,9 +744,10 @@ Standard_Boolean Visual3d_ViewManager::AddZLayer (Standard_Integer& theLayerId)
myMapOfZLayerSettings.Bind (theLayerId, Graphic3d_ZLayerSettings());
// tell all managed views to remove display layers
Visual3d_SetIteratorOfSetOfView aViewIt(MyDefinedView);
for ( ; aViewIt.More (); aViewIt.Next ())
(aViewIt.Value ())->AddZLayer (theLayerId);
for(int i=1; i<=MyDefinedView.Length(); i++)
{
(MyDefinedView.Value(i))->AddZLayer(theLayerId);
}
return Standard_True;
}
@ -856,9 +763,10 @@ Standard_Boolean Visual3d_ViewManager::RemoveZLayer (const Standard_Integer theL
return Standard_False;
// tell all managed views to remove display layers
Visual3d_SetIteratorOfSetOfView aViewIt (MyDefinedView);
for ( ; aViewIt.More (); aViewIt.Next ())
(aViewIt.Value ())->RemoveZLayer (theLayerId);
for(int i=1; i<=MyDefinedView.Length(); i++)
{
(MyDefinedView.Value(i))->RemoveZLayer (theLayerId);
}
MyGraphicDriver->UnsetZLayer (theLayerId);
@ -908,7 +816,16 @@ Aspect_GenId& Visual3d_ViewManager::getZLayerGenId ()
void Visual3d_ViewManager::InstallZLayers(const Handle(Visual3d_View)& theView) const
{
if (!MyDefinedView.Contains (theView))
Standard_Boolean isContainsView = Standard_False;
for(int i=1; i<=MyDefinedView.Length(); i++)
{
if(MyDefinedView.Value(i) == theView)
{
isContainsView = Standard_True;
break;
}
}
if (!isContainsView)
return;
// erase and insert layers iteratively to provide the same layer order as