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

0022807: Loading of STEP entities in model during reading of STEP file requires redundant memory

Browse Source
This commit is contained in:
GKA 2011-12-16 08:41:10 +00:00 committed by bugmaster
parent 251450e53f
commit bc650d4170
25 changed files with 745 additions and 942 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/IFSelect/IFSelect_Selection.cxx
View File

@ -13,7 +13,8 @@
(const Interface_Graph& G) const
{
Interface_EntityIterator iter = RootResult(G);
if (HasUniqueResult()) return iter;
if (HasUniqueResult() || !G.ModeStat())
return iter;
Interface_Graph GG(G);
GG.GetFromIter(iter,0);
return Interface_GraphContent(GG); // EntityIterator specialise (meme taille)

10
src/IFSelect/IFSelect_WorkSession.cdl
View File

@ -54,6 +54,14 @@ is
SetShareOut (me : mutable; shareout : mutable ShareOut);
---Purpose : Sets a new ShareOut. Fills Items which its content
-- Warning : data from the former ShareOut are lost
SetModeStat(me : mutable; theMode : Boolean);
---Purpose : Set value of mode responsible for precence of selections after loading
-- If mode set to true that different selections will be accessible after loading
-- else selections will be not accessible after loading( for economy memory in applicatios)
GetModeStat(me) returns Boolean from Standard;
---Purpose : Return value of mode defining of filling selection during loading
SetLibrary (me : mutable; lib : WorkLibrary);
@ -1146,5 +1154,5 @@ fields
thecopier : ModelCopier; -- produces + memorizes transferred data
theoldel : InterfaceModel;
themodelstat : Boolean;
end WorkSession;

116
src/IFSelect/IFSelect_WorkSession.cxx
View File

@ -78,6 +78,7 @@ IFSelect_WorkSession::IFSelect_WorkSession ()
thecopier->SetShareOut (theshareout);
thecheckdone = Standard_False;
thegtool = new Interface_GTool;
themodelstat = Standard_False;
}
@ -228,7 +229,7 @@ void IFSelect_WorkSession::SetModel
if (!thegtool.IsNull()) thegtool->ClearEntities(); //smh#14 FRA62479
// themodel->SetProtocol(theprotocol);
themodel->SetGTool (thegtool);
thegtool->Reservate (themodel->NbEntities()+20,Standard_True);
thegraph.Nullify();
ComputeGraph(); // fait qqchose si Protocol present. Sinon, ne fait rien
ClearData(3); // RAZ CheckList, a refaire
@ -244,7 +245,6 @@ void IFSelect_WorkSession::SetModel
//function :
//purpose :
//=======================================================================
Handle(Interface_InterfaceModel) IFSelect_WorkSession::Model () const
{
return themodel;
@ -369,8 +369,7 @@ Standard_Integer IFSelect_WorkSession::NumberFromLabel
}
if (cnt == 1) return num;
num = -num;
// if (cnt == 0) cout<<" Label:"<<val<<" -> 0 ent"<<endl;
// if (cnt > 0) cout<<" Label:"<<val<<" ->"<<cnt<<" ent.s, refus"<<endl;
return num;
}
@ -513,29 +512,35 @@ Standard_Boolean IFSelect_WorkSession::ComputeGraph
{
if (theprotocol.IsNull()) return Standard_False;
if (themodel.IsNull()) return Standard_False;
if (themodel->NbEntities() == 0) return Standard_False;
//if (themodel->NbEntities() == 0) return Standard_False;
if (enforce) thegraph.Nullify();
if (!thegraph.IsNull()) {
if (themodel->NbEntities() == thegraph->Graph().Size()) return Standard_True;
thegraph.Nullify();
}
if (themodel->NbEntities() == 0) return Standard_False;
// Il faut calculer le graphe pour de bon
thegraph = new Interface_HGraph (themodel,thegtool);
thegraph = new Interface_HGraph (themodel,themodelstat);
Standard_Integer nb = themodel->NbEntities();
Standard_Integer i; // svv #1
for (i = 1; i <= nb; i ++) thegraph->CGraph().SetStatus(i,0);
Interface_BitMap& bm = thegraph->CGraph().CBitMap();
bm.AddFlag();
bm.SetFlagName (Flag_Incorrect,"Incorrect");
if(themodelstat)
{
Standard_Integer i; // svv #1
for (i = 1; i <= nb; i ++) thegraph->CGraph().SetStatus(i,0);
Interface_BitMap& bm = thegraph->CGraph().CBitMap();
bm.AddFlag();
bm.SetFlagName (Flag_Incorrect,"Incorrect");
}
ComputeCheck();
thecheckdone = Standard_True;
// Calcul des categories, a present memorisees dans le modele
Interface_Category categ(thegtool);
Interface_ShareTool sht(thegraph);
for (i = 1; i <= nb; i ++) themodel->SetCategoryNumber
(i,categ.CatNum(themodel->Value(i),sht));
if(themodelstat)
{
// Calcul des categories, a present memorisees dans le modele
Interface_Category categ(thegtool);
Interface_ShareTool sht(thegraph);
Standard_Integer i =1;
for ( ; i <= nb; i ++) themodel->SetCategoryNumber
(i,categ.CatNum(themodel->Value(i),sht));
}
return Standard_True;
}
@ -629,20 +634,21 @@ Standard_Boolean IFSelect_WorkSession::ComputeCheck
Interface_CheckTool cht(thegraph);
Interface_CheckIterator checklist = cht.VerifyCheckList();
themodel->FillSemanticChecks(checklist,Standard_False);
// Et on met a jour le Graphe (BitMap) ! Flag Incorrect (STX + SEM)
Interface_BitMap& BM = CG.CBitMap();
BM.Init (Standard_False,Flag_Incorrect);
Standard_Integer num, nb = CG.Size();
for (checklist.Start(); checklist.More(); checklist.Next()) {
const Handle(Interface_Check) chk = checklist.Value();
if (!chk->HasFailed()) continue;
num = checklist.Number();
if (num > 0 && num <= nb) BM.SetTrue (num,Flag_Incorrect);
if(themodelstat)
{
// Et on met a jour le Graphe (BitMap) ! Flag Incorrect (STX + SEM)
Interface_BitMap& BM = CG.CBitMap();
BM.Init (Standard_False,Flag_Incorrect);
Standard_Integer num, nb = CG.Size();
for (checklist.Start(); checklist.More(); checklist.Next()) {
const Handle(Interface_Check) chk = checklist.Value();
if (!chk->HasFailed()) continue;
num = checklist.Number();
if (num > 0 && num <= nb) BM.SetTrue (num,Flag_Incorrect);
}
for (num = 1; num <= nb; num ++)
if (themodel->IsErrorEntity (num)) BM.SetTrue (num,Flag_Incorrect);
}
for (num = 1; num <= nb; num ++)
if (themodel->IsErrorEntity (num)) BM.SetTrue (num,Flag_Incorrect);
return Standard_True;
}
@ -852,7 +858,6 @@ Standard_Integer IFSelect_WorkSession::AddItem
if (id > 0) {
Handle(Standard_Transient)& att = theitems.ChangeFromIndex(id);
if (att.IsNull()) att = item;
//// if (theitems.FindFromIndex(id).IsNull()) id0 = theitems.Add(item,item);
}
else id = theitems.Add(item,item);
@ -923,17 +928,7 @@ Standard_Boolean IFSelect_WorkSession::SetActive
return Standard_True;
}
}
/* UTILISER EXPLICITEMENT SetAppliedModifier
if (item->IsKind(STANDARD_TYPE(IFSelect_GeneralModifier))) {
DeclareAndCast(IFSelect_GeneralModifier,modif,item);
if (mode) {
theshareout->AddModifier(modif,0);
return Standard_True;
} else {
return theshareout->RemoveItem(modif);
}
}
*/
return Standard_False;
}
@ -1362,8 +1357,7 @@ Interface_EntityIterator IFSelect_WorkSession::EvalSelection
}
if (thegraph.IsNull()) return iter;
// if (ItemIdent(sel) != 0) iter = sel->UniqueResult(thegraph->Graph());
iter = sel->UniqueResult(thegraph->Graph());
iter = sel->UniqueResult(thegraph->Graph());
return iter;
}
@ -1444,11 +1438,7 @@ Handle(TColStd_HSequenceOfTransient) IFSelect_WorkSession::SelectionResultFromLi
// ssel est la derniere selection auscultee, deduct son downcast
// input son Input (nulle si sel pas une deduction)
deduct = GetCasted(IFSelect_SelectDeduct,ssel);
/*
Handle(IFSelect_SelectPointed) sp = new IFSelect_SelectPointed;
sp->AddList(list);
deduct->SetInput (sp);
*/
deduct->Alternate()->SetList (list);
// On execute puis on nettoie
@ -2491,7 +2481,7 @@ IFSelect_ReturnStatus IFSelect_WorkSession::SendAll
Handle_Interface_Check aMainFail = checks.CCheck(0);
if (!aMainFail.IsNull() && aMainFail->HasFailed ())
{
return IFSelect_RetStop;
return IFSelect_RetStop;
}
if (theloaded.Length() == 0) theloaded.AssignCat(filename);
thecheckrun = checks;
@ -2828,7 +2818,7 @@ void IFSelect_WorkSession::QueryCheckList (const Interface_CheckIterator& chl)
// analyse selon le graphe ... codes : blc = rien
// 1 W/place 2 F/place 3 Wprop 4Wprop+W/place 5Wprop+F/place
// 6 Fprop 7 Fprop+W/place 8 Fprop+F/place
Interface_IntList list = thegraph->Graph().SharingNums(0);
Interface_IntList list;// = thegraph->Graph().SharingNums(0);
// deux passes : d abord Warning, puis Fail
for (i = 1; i <= nb; i ++) {
char val = thecheckana.Value(i);
@ -2899,16 +2889,6 @@ Standard_Integer IFSelect_WorkSession::QueryParent
Standard_Integer stat = QueryParent ( entdad,list->Value(i) );
if (stat >= 0) return stat+1;
}
/*
Interface_IntList sharings = thegraph->Graph().SharingNums (nson);
Standard_Integer i, nb = sharings.Length();
for (i = 1; i <= nb; i ++) {
if (sharings.Value(i) == nson) return 1;
Standard_Integer stat = QueryParent
( entson,StartingEntity(sharings.Value(i)) );
if (stat >= 0) return stat+1;
}
*/
return -1; // not yet implemented ...
}
@ -3602,7 +3582,7 @@ void IFSelect_WorkSession::PrintCheckList
Interface_CheckIterator chks = checklist;
Handle(IFSelect_CheckCounter) counter =
new IFSelect_CheckCounter (mode>1 && mode != IFSelect_CountSummary);
counter->Analyse (chks,themodel,Standard_True,failsonly);
counter->Analyse (chks,themodel,Standard_False,failsonly);
counter->PrintList (sout,themodel,mode);
}
}
@ -3884,3 +3864,13 @@ void IFSelect_WorkSession::ListEntities
sout<<"\n Abandon"<<endl;
}
}
void IFSelect_WorkSession::SetModeStat( Standard_Boolean theStatMode)
{
themodelstat = theStatMode;
}
Standard_Boolean IFSelect_WorkSession::GetModeStat() const
{
return themodelstat;
}

3
src/IGESGeom/IGESGeom_BoundedSurface.cxx
View File

@ -39,7 +39,8 @@
Standard_Integer IGESGeom_BoundedSurface::NbBoundaries () const
{
return theBoundaries->Length();
return ( theBoundaries.IsNull() ? 0 : theBoundaries->Length());
}
Handle(IGESGeom_Boundary) IGESGeom_BoundedSurface::Boundary

17
src/Interface/Interface_BitMap.cdl
View File

@ -25,16 +25,28 @@ uses CString, HSequenceOfAsciiString from TColStd,
is
Create returns BitMap;
---Purpose : Creates a empty BitMap
Create (nbitems : Integer; resflags : Integer = 0) returns BitMap;
---Purpose : Creates a BitMap for <nbitems> items
-- One flag is defined, n0 0
-- <resflags> prepares allocation for <resflags> more flags
-- Flags values start at false
Initialize(me : in out; nbitems : Integer; resflags : Integer = 0);
---Purpose : Initialize empty bit by <nbitems> items
-- One flag is defined, n0 0
-- <resflags> prepares allocation for <resflags> more flags
-- Flags values start at false
Create (other : BitMap; copied : Boolean = Standard_False) returns BitMap;
---Purpose : Creates a BitMap from another one
-- if <copied> is True, copies data
-- else, data are not copied, only the header object is
Initialize(me : in out; other : BitMap; copied : Boolean = Standard_False);
---Purpose : Initialize a BitMap from another one
Internals (me; nbitems , nbwords, nbflags : out Integer;
flags : out mutable HArray1OfInteger;
@ -108,6 +120,9 @@ is
Init (me; val : Boolean; flag : Integer = 0);
---Purpose : Initialises all the values of Flag Number <flag> to a given
-- value <val>
Clear(me: in out);
---Purpose : Clear all field of bit map
fields

113
src/Interface/Interface_BitMap.cxx
View File

@ -2,18 +2,39 @@
#include <TCollection_AsciiString.hxx>
#include <Standard_NotImplemented.hxx>
Interface_BitMap::Interface_BitMap()
{
Initialize(0);
}
Interface_BitMap::Interface_BitMap
(const Standard_Integer nbitems, const Standard_Integer resflags)
Interface_BitMap::Interface_BitMap
(const Standard_Integer nbitems, const Standard_Integer resflags)
{
Initialize(nbitems,resflags);
}
void Interface_BitMap::Initialize(const Standard_Integer nbitems, const Standard_Integer resflags)
{
thenbitems = nbitems;
thenbwords = nbitems/32 + 1;
thenbflags = 0;
theflags = new TColStd_HArray1OfInteger (0,thenbwords*(resflags+1)); theflags->Init(0);
if(nbitems)
{
theflags = new TColStd_HArray1OfInteger (0,thenbwords*(resflags+1));
theflags->Init(0);
}
}
Interface_BitMap::Interface_BitMap
(const Interface_BitMap& other, const Standard_Boolean copied)
Interface_BitMap::Interface_BitMap
(const Interface_BitMap& other, const Standard_Boolean copied)
{
Initialize(other,copied);
}
void Interface_BitMap::Initialize(const Interface_BitMap& other,
const Standard_Boolean copied)
{
other.Internals (thenbitems,thenbwords,thenbflags,theflags,thenames);
if (!copied) return;
@ -31,18 +52,18 @@
thenames = names;
}
void Interface_BitMap::Internals
(Standard_Integer& nbitems, Standard_Integer& nbwords,
Standard_Integer& nbflags,
Handle(TColStd_HArray1OfInteger)& flags,
Handle(TColStd_HSequenceOfAsciiString)& names) const
void Interface_BitMap::Internals
(Standard_Integer& nbitems, Standard_Integer& nbwords,
Standard_Integer& nbflags,
Handle(TColStd_HArray1OfInteger)& flags,
Handle(TColStd_HSequenceOfAsciiString)& names) const
{
nbitems = thenbitems; nbwords = thenbwords; nbflags = thenbflags;
flags = theflags; names = thenames;
}
void Interface_BitMap::Reservate (const Standard_Integer moreflags)
void Interface_BitMap::Reservate (const Standard_Integer moreflags)
{
Standard_Integer nb = theflags->Upper ();
Standard_Integer nbflags = nb / thenbwords - 1; // flag 0 non compte ...
@ -57,7 +78,7 @@
}
void Interface_BitMap::SetLength (const Standard_Integer nbitems)
void Interface_BitMap::SetLength (const Standard_Integer nbitems)
{
Standard_Integer nbw = nbitems/32 + 1;
if (nbw == thenbwords) return;
@ -77,7 +98,7 @@
}
Standard_Integer Interface_BitMap::AddFlag (const Standard_CString name)
Standard_Integer Interface_BitMap::AddFlag (const Standard_CString name)
{
Reservate(1);
Standard_Integer deja = 0;
@ -86,7 +107,7 @@
Standard_Integer i, nb = thenames->Length();
for (i = 1; i <= nb; i ++) {
if (thenames->Value(i).IsEqual("."))
{ thenames->ChangeValue(i).AssignCat(name); deja = i; }
{ thenames->ChangeValue(i).AssignCat(name); deja = i; }
}
}
if (!deja) thenames->Append (TCollection_AsciiString(name));
@ -94,8 +115,8 @@
return (deja ? deja : thenbflags);
}
Standard_Integer Interface_BitMap::AddSomeFlags
(const Standard_Integer more)
Standard_Integer Interface_BitMap::AddSomeFlags
(const Standard_Integer more)
{
Reservate(more);
if (thenames.IsNull()) thenames = new TColStd_HSequenceOfAsciiString();
@ -105,8 +126,8 @@
return thenbflags;
}
Standard_Boolean Interface_BitMap::RemoveFlag
(const Standard_Integer num)
Standard_Boolean Interface_BitMap::RemoveFlag
(const Standard_Integer num)
{
if (num < 1 || num > thenames->Length()) return Standard_False;
if (num == thenames->Length()) thenames->Remove (thenames->Length());
@ -115,8 +136,8 @@
return Standard_True;
}
Standard_Boolean Interface_BitMap::SetFlagName
(const Standard_Integer num, const Standard_CString name)
Standard_Boolean Interface_BitMap::SetFlagName
(const Standard_Integer num, const Standard_CString name)
{
if (num < 1 || num > thenames->Length()) return Standard_False;
Standard_Integer deja = (name[0] == '\0' ? 0 : FlagNumber (name) );
@ -125,22 +146,22 @@
return Standard_True;
}
Standard_Integer Interface_BitMap::NbFlags () const
{ return thenbflags; }
Standard_Integer Interface_BitMap::NbFlags () const
{ return thenbflags; }
Standard_Integer Interface_BitMap::Length () const
{ return thenbitems; }
Standard_Integer Interface_BitMap::Length () const
{ return thenbitems; }
Standard_CString Interface_BitMap::FlagName
(const Standard_Integer num) const
Standard_CString Interface_BitMap::FlagName
(const Standard_Integer num) const
{
if (theflags.IsNull()) return "";
if (num < 1 || num > thenames->Length()) return "";
return thenames->Value(num).ToCString();
}
Standard_Integer Interface_BitMap::FlagNumber
(const Standard_CString name) const
Standard_Integer Interface_BitMap::FlagNumber
(const Standard_CString name) const
{
if (name[0] == '\0') return 0;
if (thenames.IsNull()) return 0;
@ -153,8 +174,8 @@
// Les valeurs ...
Standard_Boolean Interface_BitMap::Value
(const Standard_Integer item, const Standard_Integer flag) const
Standard_Boolean Interface_BitMap::Value
(const Standard_Integer item, const Standard_Integer flag) const
{
Standard_Integer numw = (thenbwords * flag) + (item >> 5);
const Standard_Integer& val = theflags->Value (numw);
@ -164,24 +185,24 @@
return ( ((1 << numb) & val) != 0);
}
void Interface_BitMap::SetValue
(const Standard_Integer item, const Standard_Boolean val,
const Standard_Integer flag) const
void Interface_BitMap::SetValue
(const Standard_Integer item, const Standard_Boolean val,
const Standard_Integer flag) const
{
if (val) SetTrue (item,flag);
else SetFalse (item,flag);
}
void Interface_BitMap::SetTrue
(const Standard_Integer item, const Standard_Integer flag) const
void Interface_BitMap::SetTrue
(const Standard_Integer item, const Standard_Integer flag) const
{
Standard_Integer numw = (thenbwords * flag) + (item >> 5);
Standard_Integer numb = item & 31;
theflags->ChangeValue (numw) |= (1 << numb);
}
void Interface_BitMap::SetFalse
(const Standard_Integer item, const Standard_Integer flag) const
void Interface_BitMap::SetFalse
(const Standard_Integer item, const Standard_Integer flag) const
{
Standard_Integer numw = (thenbwords * flag) + (item >> 5);
Standard_Integer& val = theflags->ChangeValue (numw);
@ -190,8 +211,8 @@
theflags->ChangeValue (numw) &= ~(1 << numb);
}
Standard_Boolean Interface_BitMap::CTrue
(const Standard_Integer item, const Standard_Integer flag) const
Standard_Boolean Interface_BitMap::CTrue
(const Standard_Integer item, const Standard_Integer flag) const
{
Standard_Integer numw = (thenbwords * flag) + (item >> 5);
Standard_Integer numb = item & 31;
@ -203,8 +224,8 @@
return (res != 0);
}
Standard_Boolean Interface_BitMap::CFalse
(const Standard_Integer item, const Standard_Integer flag) const
Standard_Boolean Interface_BitMap::CFalse
(const Standard_Integer item, const Standard_Integer flag) const
{
Standard_Integer numw = (thenbwords * flag) + (item >> 5);
Standard_Integer numb = item & 31;
@ -217,11 +238,17 @@
}
void Interface_BitMap::Init
(const Standard_Boolean val, const Standard_Integer flag) const
void Interface_BitMap::Init
(const Standard_Boolean val, const Standard_Integer flag) const
{
Standard_Integer i, ii = thenbwords, i1 = thenbwords *flag;
if (flag < 0) { i1 = 0; ii = thenbwords*(thenbflags+1); }
if (val) for (i = 0; i < ii; i ++) theflags->SetValue (i1+i,~(0));
else for (i = 0; i < ii; i ++) theflags->SetValue (i1+i, 0 );
}
void Interface_BitMap::Clear()
{
theflags.Nullify();
Initialize(0);
}

5
src/Interface/Interface_FileReaderTool.cdl
View File

@ -174,7 +174,10 @@ is
EndRead (me : in out; amodel : mutable InterfaceModel) is virtual;
---Purpose : Ends file reading after reading all the entities
-- default is doing nothing; redefinable as necessary
Clear(me : in out);
---Purpose : Clear filelds
fields

10
src/Interface/Interface_FileReaderTool.cxx
View File

@ -547,5 +547,13 @@ Handle(Standard_Transient) Interface_FileReaderTool::LoadedEntity
//purpose :
//=======================================================================
void Interface_FileReaderTool::Destroy(){}
void Interface_FileReaderTool::Destroy()
{}
void Interface_FileReaderTool::Clear()
{
theproto.Nullify();
thereader.Nullify();
themodel.Nullify();
thereports.Nullify();
}

12
src/Interface/Interface_GTool.cxx
View File

@ -67,17 +67,17 @@ Standard_Boolean Interface_GTool::Select (const Handle(Standard_Transient)& ent
Standard_Integer& CN,
const Standard_Boolean enforce)
{
// const Handle(Standard_Type)& aType = ent->DynamicType();
Standard_Integer num = thentmod.FindIndex (ent);
const Handle(Standard_Type)& aType = ent->DynamicType();
Standard_Integer num = thentmod.FindIndex(aType);// (ent);
if (num == 0 || enforce) {
if (thelib.Select (ent,gmod,CN)) {
num = thentmod.Add (ent,gmod);
thentnum.Bind (ent,CN);
num = thentmod.Add (aType,gmod);
thentnum.Bind (aType,CN);
return Standard_True;
}
return Standard_False;
}
gmod = Handle(Interface_GeneralModule)::DownCast (thentmod.FindFromIndex(num));
CN = thentnum.Find (ent);
gmod = Handle(Interface_GeneralModule)::DownCast (thentmod.FindFromKey(aType));
CN = thentnum.Find (aType);
return Standard_True;
}

150
src/Interface/Interface_Graph.cdl
View File

@ -28,39 +28,45 @@ class Graph from Interface
-- be changed or reset (i.e. to come back to standard answer)
uses Transient, Type,
Array1OfInteger from TColStd,
HArray1OfInteger from TColStd,
HArray1OfTransient from TColStd,
HSequenceOfTransient from TColStd,
HArray1OfListOfInteger from TColStd,
AsciiString from TCollection, HAsciiString from TCollection,
Protocol from Interface, GeneralLib, InterfaceModel, GTool,
EntityIterator, IntList, BitMap
EntityIterator, BitMap
raises DomainError
is
Create (amodel : InterfaceModel; lib : GeneralLib) returns Graph;
Create (amodel : InterfaceModel; lib : GeneralLib; theModeStats : Boolean = Standard_True ) returns Graph;
---Purpose : Creates an empty graph, ready to receive Entities from amodel
-- Note that this way of Creation allows <me> to verify that
-- Entities to work with are contained in <amodel>
-- Basic Shared and Sharing lists are obtained from a General
-- Services Library, given directly as an argument
Create (amodel : InterfaceModel; protocol : Protocol from Interface)
Create (amodel : InterfaceModel; protocol : Protocol from Interface;
theModeStats : Boolean = Standard_True)
returns Graph;
---Purpose : Same as above, but the Library is defined through a Protocol
Create (amodel : InterfaceModel; gtool : GTool from Interface)
Create (amodel : InterfaceModel; gtool : GTool from Interface;
theModeStats : Boolean = Standard_True)
returns Graph;
---Purpose : Same as above, but the Library is defined through a Protocol
Create (amodel : InterfaceModel) returns Graph;
Create (amodel : InterfaceModel;theModeStats : Boolean = Standard_True) returns Graph;
---Purpose : Same a above but works with the Protocol recorded in the Model
Create (agraph : Graph; copied : Boolean = Standard_False) returns Graph;
Create (agraph : Graph; copied : Boolean = Standard_False) returns Graph;
---Purpose : Creates a Graph from another one, getting all its data
-- Remark that status are copied from <agraph>, but the other
-- lists (sharing/shared) are copied only if <copied> = True
Evaluate (me : in out; lib : GeneralLib; gtool : GTool) is static private;
Evaluate (me : in out ) is static private;
---Purpose : Performs the Evaluation of the Graph, from an initial Library,
-- either defined through a Protocol, or given dierctly
-- Called by the non-empty Constructors
@ -69,25 +75,6 @@ is
-- GeneralLib directly, it cannot be used
-- If <gtool> is defined, it has priority
EvalSharings (me : in out) is static;
---Purpose : Reevaluates the Sharing Lists of the Graph, starting from the
-- Shared Lists (priority to the redefined ones)
BasicSharedTable (me) returns IntList is static private;
---Purpose : Returns the Table of Basic Shared lists. Used to Create
-- another Graph from <me>
RedefinedSharedTable (me) returns IntList is static private;
---Purpose : Returns the Table of redefined Shared lists. Used to Create
-- another Graph from <me>. Null Handle is no one redefinition
SharingTable (me) returns IntList is static private;
---Purpose : Returns the Table of Sharing lists. Used to Create
-- another Graph from <me>
-- NbVertex(me) returns Integer is static; -- for GraphTools requirements
Reset (me : in out) is static;
---Purpose : Erases data, making graph ready to rebegin from void
@ -101,6 +88,9 @@ is
---Purpose : Returns size (max nb of entities, i.e. Model's nb of entities)
-- -- Fine Actions -- --
NbStatuses(me) returns Integer;
---Purpose : Returns size of array of statuses
EntityNumber (me; ent : Transient) returns Integer is static;
---Purpose : Returns the Number of the entity in the Map, computed at
@ -125,10 +115,6 @@ is
Status (me; num : Integer) returns Integer is static;
---Purpose : Returns Status associated to a numero (only to read it)
CStatus (me : in out; num : Integer) returns Integer is static;
---Purpose : Returns Status associated to a numero, to be read or changed
---C++ : return &
SetStatus (me : in out; num : Integer; stat : Integer) is static;
---Purpose : Modifies Status associated to a numero
@ -215,23 +201,16 @@ is
-- Remark : apart from the status HasShareError, these items
-- are ignored
HasRedefinedShareds (me; ent : Transient) returns Boolean is static;
---Purpose : Returns True if Shared list of <ent> has been redefined
-- (Thus, Shareds from Graph gives a result different from
-- general service Shareds)
GetShareds(me; ent : Transient) returns HSequenceOfTransient;
---Purpose : Returns the sequence of Entities Shared by an Entity
Shareds (me; ent : Transient) returns EntityIterator
---Purpose : Returns the list of Entities Shared by an Entity, as recorded
-- by the Graph. That is, by default Basic Shared List, else it
-- can be redefined by methods SetShare, SetNoShare ... see below
raises DomainError is static;
-- Error if <ent> is not contained by the model used for Creation
SharedNums (me; num : Integer) returns IntList is static;
---Purpose : Same as Shareds, but under the form of a list of Integers,
-- each one beeing the Number of a Shared Entity in the Graph
-- Especially intended for fast internal uses
-- Returns a Null Handle if <num> is not contained by <themodel>
Sharings (me; ent : Transient) returns EntityIterator
---Purpose : Returns the list of Entities which Share an Entity, computed
@ -239,83 +218,46 @@ is
raises DomainError is static;
-- Error if <ent> is not contained by the model used for Creation
SharingNums (me; num : Integer) returns IntList is static;
---Purpose : Same as Sharings, but under the form of a list of Integers
-- each one beeing the Number of a Sharing Entity in the Graph
TypedSharings (me; ent : Transient; type : Type) returns EntityIterator;
GetSharings(me; ent : Transient) returns HSequenceOfTransient;
---Purpose : Returns the sequence of Entities Sharings by an Entity
TypedSharings (me; ent : Transient; type : Type) returns EntityIterator;
---Purpose : Returns the list of sharings entities, AT ANY LEVEL, which are
-- kind of a given type. A sharing entity kind of this type
-- ends the exploration of its branch
RootEntities (me) returns EntityIterator is static;
---Purpose : Returns the Entities which are not Shared (their Sharing List
-- is empty) in the Model
-- -- Redefinitions of Shared-Sharing Lists -- --
SetShare (me : in out; ent : Transient) is static;
---Purpose : Sets explicit the shared list of an Entity <ent>, that is,
-- available for a further edit (Add/Remove). All SetShare and
-- SetNoShare methods allow further edit operations.
-- Effect cancelled by ResetShare
-- Remark that all Redefinition methods work on Shared Lists,
-- but also manage (update) the Sharing Lists
SetShare (me : in out; ent : Transient; list : EntityIterator)
is static;
---Purpose : Sets as Shared list of an Entity <ent> considered by <me>,
-- the list given as an EntityIterator <iter>. It can be empty.
-- This list will now be considered by method Shareds above
-- Does nothing if <ent> is not contained by <themodel>
SetShare (me : in out; ent : Transient; list : IntList)
is static;
---Purpose : Same as above, but the list is given as the list of Numbers
-- of the Entities shared by <ent>
SetNoShare (me : in out; ent : Transient) is static;
---Purpose : Sets the Shared list of an Entity considered in <me> as beeing
-- Empty (if <ent> is contained by <themodel>)
SetNoShare (me : in out; list : EntityIterator) is static;
---Purpose : Sets the Shared lists of a list of Entities to be Empty
AddShared (me : in out; ent,shared : Transient)
---Purpose : Adds a shared Entity to a redefined Shared List (formerly
-- defined by SetShare or SetNoShare). Does nothing if already in
raises DomainError is static;
-- Error if no shared list was formerly redefined for <ent>
RemoveShared (me : in out; ent,shared : Transient)
---Purpose : Removes a shared Entity from a redefined Shared List (formerly
-- defined ...). Does nothing if <shared> no in the list
raises DomainError is static;
-- Error if no shared list was formerly redefined for <ent>
ResetShare (me : in out; ent : Transient) is static;
---Purpose : Comes back to the standard Shared list for <ent> : Cancels all
-- the former redefinitions for it
ResetAllShare (me : in out) is static;
---Purpose : Clears all effects of former redefinition of Shared lists
Name (me; ent : Transient) returns HAsciiString;
---Purpose : Determines the name attached to an entity, by using the
-- general service Name in GeneralModule
-- Returns a null handle if no name could be computed or if
-- the entity is not in the model
SharingTable (me) returns HArray1OfListOfInteger from TColStd; --HArray1OfTransient from TColStd ;
---C++ : return const &
---Purpose : Returns the Table of Sharing lists. Used to Create
-- another Graph from <me>
InitStats(me : in out) is protected;
---Purpose : Initialize statuses and flags
ModeStat(me) returns Boolean;
---Purpose : Returns mode resposible for computation of statuses;
fields
themodel : InterfaceModel; -- Model which contains the Entities
thepresents : AsciiString from TCollection; -- flags present/or not
thestats : Array1OfInteger from TColStd; -- numeric status
themodel : InterfaceModel is protected ; -- Model which contains the Entities
thepresents : AsciiString from TCollection is protected ; -- flags present/or not
thestats : HArray1OfInteger from TColStd is protected; -- numeric status
theflags : BitMap; -- logical flags status
theshareds : IntList; -- Basic Shared Lists (one per Entity)
thesharnews : IntList; -- Shared Lists Redefinitions
thesharings : IntList; -- The Sharing Lists (one per Entity)
thesharings : HArray1OfListOfInteger from TColStd is protected; --HArray1OfTransient from TColStd is protected;
end Graph;

802
src/Interface/Interface_Graph.cxx
View File

@ -4,8 +4,9 @@
#include <Standard_DomainError.hxx>
#include <TColStd_Array1OfInteger.hxx>
#include <Interface_ShareTool.hxx>
#include <TColStd_HSequenceOfTransient.hxx>
#include <TColStd_ListIteratorOfListOfInteger.hxx>
#include <Interface_GTool.hxx>
// Flags : 0 = Presence, 1 = Sharing Error
#define Graph_Present 0
@ -19,362 +20,327 @@
// .... Construction a partir de la connaissance des Entites ....
Interface_Graph::Interface_Graph
(const Handle(Interface_InterfaceModel)& amodel,
const Interface_GeneralLib& lib)
: themodel (amodel), thepresents ("") , thestats (0,amodel->NbEntities()) ,
theflags (amodel->NbEntities(),2) ,
theshareds (amodel->NbEntities()) , /*thesharnews(amodel->NbEntities()) , */
thesharings (amodel->NbEntities())
Interface_Graph::Interface_Graph
(const Handle(Interface_InterfaceModel)& amodel,
const Interface_GeneralLib& lib,
Standard_Boolean theModeStat)
: themodel (amodel), thepresents ("")
{
Handle(Interface_GTool) gtool; // null
theflags.AddFlag ("ShareError"); // -> flag n0 1
Evaluate(lib,gtool);
if(theModeStat)
InitStats();
Evaluate();
}
Interface_Graph::Interface_Graph
(const Handle(Interface_InterfaceModel)& amodel,
const Handle(Interface_Protocol)& protocol)
: themodel (amodel) , thepresents ("") ,
thestats (0,amodel->NbEntities()) , theflags (amodel->NbEntities(),2) ,
theshareds (amodel->NbEntities()) , /*thesharnews(amodel->NbEntities()) ,*/
thesharings (amodel->NbEntities())
Interface_Graph::Interface_Graph
(const Handle(Interface_InterfaceModel)& amodel,
const Handle(Interface_Protocol)& protocol,
Standard_Boolean theModeStat)
: themodel (amodel) , thepresents ("")
{
Handle(Interface_GTool) gtool; // null
theflags.AddFlag ("ShareError"); // -> flag n0 1
Evaluate(Interface_GeneralLib(protocol),gtool);
if(theModeStat)
InitStats();
Evaluate();
}
Interface_Graph::Interface_Graph
(const Handle(Interface_InterfaceModel)& amodel,
const Handle(Interface_GTool)& gtool)
: themodel (amodel) , thepresents ("") ,
thestats (0,amodel->NbEntities()) , theflags (amodel->NbEntities(),2) ,
theshareds (amodel->NbEntities()) , /*thesharnews(amodel->NbEntities()) , */
thesharings (amodel->NbEntities())
Interface_Graph::Interface_Graph
(const Handle(Interface_InterfaceModel)& amodel,
const Handle(Interface_GTool)& gtool,
Standard_Boolean theModeStat)
: themodel (amodel) , thepresents ("")
{
theflags.AddFlag ("ShareError"); // -> flag n0 1
Evaluate(gtool->Lib(),gtool);
if(theModeStat)
InitStats();
Evaluate();
}
Interface_Graph::Interface_Graph
(const Handle(Interface_InterfaceModel)& amodel)
: themodel (amodel) , thepresents ("") ,
thestats (0,amodel->NbEntities()) , theflags (amodel->NbEntities(),2) ,
theshareds (amodel->NbEntities()) ,
/*thesharnews(amodel->NbEntities()) ,*/ thesharings (amodel->NbEntities())
Interface_Graph::Interface_Graph
(const Handle(Interface_InterfaceModel)& amodel,
Standard_Boolean theModeStat)
: themodel (amodel) , thepresents ("")
{
theflags.AddFlag ("ShareError"); // -> flag n0 1
Handle(Interface_GTool) gtool = amodel->GTool();
if (gtool.IsNull()) return;
gtool->Reservate(amodel->NbEntities());
Evaluate (gtool->Lib(),gtool);
if(theModeStat)
InitStats();
Evaluate ();
}
void Interface_Graph::Evaluate
(const Interface_GeneralLib& lib, const Handle(Interface_GTool)& gtool)
{
// Evaluation d un Graphe de dependances : sur chaque Entite, on prend sa
// liste "Shared". On en deduit les "Sharing" directement
Standard_Boolean patool = gtool.IsNull();
Standard_Integer n = Size(), total = 0;
theshareds.Clear();
thesharings.Clear();
TColStd_Array1OfInteger counts (0,n); counts.Init(0);
TColStd_Array1OfInteger lasts (0,n); lasts.Init(0);
Standard_Integer i; // svv Jan11 2000 : porting on DEC
for (i = 1; i <= n; i ++) {
theshareds.SetNumber (i);
// ATTENTION : Si Entite non chargee donc illisible, basculer sur son
// "Contenu" equivalent
Handle(Standard_Transient) ent = themodel->Value(i);
if (themodel->IsRedefinedContent(i)) ent = themodel->ReportEntity(i)->Content();
// Resultat obtenu via GeneralLib
Interface_EntityIterator iter;
Handle(Interface_GeneralModule) module;
Standard_Integer CN;
if (patool) {
if (lib.Select(ent,module,CN)) module->FillShared(themodel,CN,ent,iter);
} else {
if (gtool->Select(ent,module,CN)) module->FillShared(themodel,CN,ent,iter);
}
theshareds.Reservate (iter.NbEntities());
// Mise en forme : liste d entiers
for (iter.Start(); iter.More(); iter.Next()) {
// num = 0 -> on sort du Model de depart, le noter "Error" et passer
Standard_Integer num = EntityNumber(iter.Value());
if (num == 0) theflags.SetTrue (i,Graph_ShareError);
else {
// controle d unicite de couple (pere-fils)
if (lasts(num) == i) continue;
total ++;
lasts.ChangeValue(num) = i;
theshareds.Add (num);
counts.ChangeValue(num) ++;
// References inverses : plus tard
}
}
}
// Les references inverses : preallocation (pour compte > 1 seulement)
thesharings.SetNumber(0); thesharings.Reservate (total);
for (i = 1; i <= n; i ++) {
if (counts(i) < 2) continue;
thesharings.SetNumber(i);
thesharings.Reservate (-counts(i));
}
// Enregistrement par inversion
for (i = 1; i <= n; i ++) {
theshareds.SetNumber (i);
Standard_Integer j,num, nb = theshareds.Length();
for (j = 1; j <= nb; j ++) {
num = theshareds.Value(j);
thesharings.SetNumber(-num);
thesharings.Add(-i);
}
}
}
void Interface_Graph::EvalSharings ()
{
thesharings.Clear();
Standard_Integer n = thesharings.NbEntities();
// Difference avec Evaluate : SharedNums prend les Redefinis si necessaire
for (Standard_Integer i = 1; i <= n; i ++) {
Standard_Integer nb, num;
if (thesharnews.IsRedefined(i)) {
thesharnews.SetNumber(i);
nb = thesharnews.Length();
for (Standard_Integer j = 1; j <= nb; j ++) {
num = thesharnews.Value (j);
thesharings.SetNumber (num);
thesharings.Reservate (thesharings.Length()+1);
thesharings.Add (i);
}
} else {
theshareds.SetNumber(i);
nb = theshareds.Length();
for (Standard_Integer j = 1; j <= nb; j ++) {
num = theshareds.Value (j);
thesharings.SetNumber (num);
thesharings.Reservate (thesharings.Length()+1);
thesharings.Add (i);
}
}
}
}
// .... Construction depuis un autre Graph ....
Interface_Graph::Interface_Graph
(const Interface_Graph& agraph, const Standard_Boolean /*copied*/)
: themodel (agraph.Model()), thepresents ("") ,
thestats (0,agraph.Size()) ,
theflags (agraph.BitMap(),Standard_True) ,
theshareds (agraph.BasicSharedTable(),Standard_True) ,
thesharnews (agraph.RedefinedSharedTable(),Standard_True) ,
thesharings (agraph.SharingTable(),Standard_True)
Interface_Graph::Interface_Graph
(const Interface_Graph& agraph, const Standard_Boolean /*copied*/)
: themodel (agraph.Model()), thepresents ("")
{
Standard_Integer nb = Size();
thesharings = agraph.SharingTable();
Standard_Integer nb = agraph.NbStatuses();
if(!nb)
return;
if(thestats.IsNull())
thestats = new TColStd_HArray1OfInteger(1,nb);
for (Standard_Integer i = 1; i <= nb; i ++)
thestats.SetValue (i,agraph.Status(i));
thestats->SetValue (i,agraph.Status(i));
theflags.Initialize(agraph.BitMap(),Standard_True);
}
Interface_IntList Interface_Graph::BasicSharedTable () const
{ return theshareds; }
void Interface_Graph::InitStats()
{
thestats = new TColStd_HArray1OfInteger(1,themodel->NbEntities()) ,
theflags.Initialize(themodel->NbEntities(),2);
theflags.AddFlag ("ShareError");
}
Interface_IntList Interface_Graph::RedefinedSharedTable () const
{ return thesharnews; }
Standard_Integer Interface_Graph::NbStatuses() const
{
return (thestats.IsNull() ? 0 : thestats->Length());
}
Interface_IntList Interface_Graph::SharingTable () const
{ return thesharings; }
const Handle(TColStd_HArray1OfListOfInteger)& Interface_Graph::SharingTable () const
{ return thesharings; }
void Interface_Graph::Evaluate()
{
// Evaluation d un Graphe de dependances : sur chaque Entite, on prend sa
// liste "Shared". On en deduit les "Sharing" directement
Standard_Integer n = Size(), total = 0;
thesharings = new TColStd_HArray1OfListOfInteger(1,n);//TColStd_HArray1OfTransient(1,n);//Clear();
if(themodel->GTool().IsNull())
return;
Standard_Integer i; // svv Jan11 2000 : porting on DEC
for (i = 1; i <= n; i ++) {
// ATTENTION : Si Entite non chargee donc illisible, basculer sur son
// "Contenu" equivalent
Handle(Standard_Transient) ent = themodel->Value(i);
// Resultat obtenu via GeneralLib
Interface_EntityIterator iter = GetShareds(ent);
// Mise en forme : liste d entiers
for (iter.Start(); iter.More(); iter.Next()) {
// num = 0 -> on sort du Model de depart, le noter "Error" et passer
Handle(Standard_Transient) entshare = iter.Value();
if(entshare == ent)
continue;
Standard_Integer num = EntityNumber(entshare);
if (!num )
{
if(!thestats.IsNull())
theflags.SetTrue (i,Graph_ShareError);
continue;
}
thesharings->ChangeValue(num).Append(i);
}
}
}
// .... Construction depuis un autre Graph ....
// ###########################################################################
// .... ACCES UNITAIRES AUX DONNEES DE BASE ....
void Interface_Graph::Reset ()
void Interface_Graph::Reset ()
{
thestats.Init(0);
theflags.Init (Standard_False, Graph_Present);
thesharnews.Clear();
EvalSharings();
if(!thestats.IsNull())
{
thestats.Nullify();
theflags.Init (Standard_False, Graph_Present);
}
}
void Interface_Graph::ResetStatus ()
{ thestats.Init(0); theflags.Init (Standard_False, Graph_Present); }
Standard_Integer Interface_Graph::Size () const
{ return thestats.Upper(); }
Standard_Integer Interface_Graph::EntityNumber
(const Handle(Standard_Transient)& ent) const
{ return themodel->Number(ent); }
Standard_Boolean Interface_Graph::IsPresent
(const Standard_Integer num) const
{
if (num <= 0 || num > Size()) return Standard_False;
return theflags.Value (num,Graph_Present);
}
Standard_Boolean Interface_Graph::IsPresent
(const Handle(Standard_Transient)& ent) const
{ return IsPresent(EntityNumber(ent)); }
const Handle(Standard_Transient)& Interface_Graph::Entity
(const Standard_Integer num) const
{ return themodel->Value(num); }
Standard_Integer Interface_Graph::Status (const Standard_Integer num) const
{ return thestats.Value(num); }
Standard_Integer& Interface_Graph::CStatus (const Standard_Integer num)
{ return thestats.ChangeValue(num); }
void Interface_Graph::SetStatus
(const Standard_Integer num, const Standard_Integer stat)
{ thestats.SetValue(num,stat); }
void Interface_Graph::RemoveItem(const Standard_Integer num)
{
thestats.SetValue(num,0); theflags.SetFalse (num,Graph_Present);
}
void Interface_Graph::ChangeStatus
(const Standard_Integer oldstat, const Standard_Integer newstat)
{
Standard_Integer nb = thestats.Upper();
for (Standard_Integer i = 1; i <= nb; i ++) {
if (thestats.Value(i) == oldstat) thestats.SetValue(i,newstat);
void Interface_Graph::ResetStatus ()
{
if(!thestats.IsNull())
{
thestats->Init(0);
theflags.Init (Standard_False, Graph_Present);
}
}
void Interface_Graph::RemoveStatus(const Standard_Integer stat)
Standard_Integer Interface_Graph::Size () const
{ return themodel->NbEntities(); }//thestats.Upper(); }
Standard_Integer Interface_Graph::EntityNumber
(const Handle(Standard_Transient)& ent) const
{ return themodel->Number(ent); }
Standard_Boolean Interface_Graph::IsPresent
(const Standard_Integer num) const
{
Standard_Integer nb = thestats.Upper();
for (Standard_Integer i = 1; i <= nb; i ++) {
if (thestats.Value(i) == stat) RemoveItem(i);
if (num <= 0 || num > Size())
return Standard_False;
return (!thestats.IsNull() ? theflags.Value (num,Graph_Present) : Standard_False);
}
Standard_Boolean Interface_Graph::IsPresent
(const Handle(Standard_Transient)& ent) const
{ return IsPresent(EntityNumber(ent)); }
const Handle(Standard_Transient)& Interface_Graph::Entity
(const Standard_Integer num) const
{
return themodel->Value(num);
}
Standard_Integer Interface_Graph::Status (const Standard_Integer num) const
{
return (!thestats.IsNull() ? thestats->Value(num) : 0);
}
void Interface_Graph::SetStatus
(const Standard_Integer num, const Standard_Integer stat)
{
if(!thestats.IsNull())
thestats->SetValue(num,stat);
}
void Interface_Graph::RemoveItem(const Standard_Integer num)
{
if(!thestats.IsNull())
{
thestats->SetValue(num,0);
theflags.SetFalse (num,Graph_Present);
}
}
const Interface_BitMap& Interface_Graph::BitMap () const
{ return theflags; }
void Interface_Graph::ChangeStatus
(const Standard_Integer oldstat, const Standard_Integer newstat)
{
if(thestats.IsNull())
return;
Standard_Integer nb = thestats->Upper();
for (Standard_Integer i = 1; i <= nb; i ++) {
if (thestats->Value(i) == oldstat)
thestats->SetValue(i,newstat);
}
}
Interface_BitMap& Interface_Graph::CBitMap ()
{ return theflags; }
void Interface_Graph::RemoveStatus(const Standard_Integer stat)
{
if(thestats.IsNull())
return;
Standard_Integer nb = thestats->Upper();
for (Standard_Integer i = 1; i <= nb; i ++) {
if (thestats->Value(i) == stat) RemoveItem(i);
}
}
const Interface_BitMap& Interface_Graph::BitMap () const
{ return theflags; }
Interface_BitMap& Interface_Graph::CBitMap ()
{ return theflags; }
// ###########################################################################
// .... Chargements Elementaires avec Propagation de "Share" .... //
const Handle(Interface_InterfaceModel)& Interface_Graph::Model() const
{ return themodel; }
const Handle(Interface_InterfaceModel)& Interface_Graph::Model() const
{ return themodel; }
void Interface_Graph::GetFromModel ()
void Interface_Graph::GetFromModel ()
{
if (themodel.IsNull()) return; // no model ... (-> on n ira pas loin)
if (themodel.IsNull() || thestats.IsNull())
return; // no model ... (-> on n ira pas loin)
theflags.Init (Standard_True,Graph_Present);
thestats.Init (0);
thestats->Init (0);
}
void Interface_Graph::GetFromEntity
(const Handle(Standard_Transient)& ent, const Standard_Boolean shared,
const Standard_Integer newstat)
void Interface_Graph::GetFromEntity
(const Handle(Standard_Transient)& ent, const Standard_Boolean shared,
const Standard_Integer newstat)
{
if(thestats.IsNull())
return;
Standard_Integer num = EntityNumber(ent);
if (num == 0) return;
if (!num )
return;
if (theflags.CTrue(num,Graph_Present)) return; // deja pris : on passe
thestats.SetValue(num,newstat);
thestats->SetValue(num,newstat);
if (!shared) return;
// Attention a la redefinition !
Interface_IntList list = thesharnews;
if (!list.IsRedefined(num)) list = theshareds;
list.SetNumber (num);
// Attention a la redefinition !
Interface_EntityIterator aIter = GetShareds(ent);
Standard_Integer nb = list.Length();
for (Standard_Integer i = 1; i <= nb; i ++) GetFromEntity
(themodel->Value (list.Value(i)),Standard_True,newstat);
for ( ; aIter.More() ; aIter.Next())
GetFromEntity(aIter.Value(),Standard_True,newstat);
}
void Interface_Graph::GetFromEntity
(const Handle(Standard_Transient)& ent, const Standard_Boolean shared,
const Standard_Integer newstat, const Standard_Integer overlapstat,
const Standard_Boolean cumul)
void Interface_Graph::GetFromEntity
(const Handle(Standard_Transient)& ent, const Standard_Boolean shared,
const Standard_Integer newstat, const Standard_Integer overlapstat,
const Standard_Boolean cumul)
{
if(thestats.IsNull())
return;
Standard_Integer num = EntityNumber(ent);
if (num == 0) return;
if (!num ) return;
Standard_Boolean pasla = !theflags.CTrue (num,Graph_Present);
Standard_Integer stat = thestats.Value(num);
Standard_Integer stat = thestats->Value(num);
if (pasla) {
/// theflags.SetTrue (num, Graph_Present); // nouveau : noter avec newstat
thestats.SetValue(num,newstat);
/// theflags.SetTrue (num, Graph_Present); // nouveau : noter avec newstat
thestats->SetValue(num,newstat);
} else {
Standard_Integer overstat = stat;
if (stat != newstat) { // deja pris, meme statut : passer
if (cumul) overstat += overlapstat; // nouveau statut : avec cumul ...
else overstat = overlapstat; // ... ou sans (statut force)
if (stat != overstat) // si repasse deja faite, passer
thestats.SetValue(num,overstat);
thestats->SetValue(num,overstat);
}
}
if (!shared) return;
// Attention a la redefinition !
Interface_IntList list = thesharnews;
if (!list.IsRedefined(num)) list = theshareds;
list.SetNumber (num);
Standard_Integer nb = list.Length();
for (Standard_Integer i = 1; i <= nb; i ++) GetFromEntity
(themodel->Value (list.Value(i)),Standard_True,newstat);
// Attention a la redefinition !
Interface_EntityIterator aIter = GetShareds(ent);
for ( ; aIter.More() ; aIter.Next())
GetFromEntity(aIter.Value(),Standard_True,newstat);
}
void Interface_Graph::GetFromIter
(const Interface_EntityIterator& iter, const Standard_Integer newstat)
void Interface_Graph::GetFromIter
(const Interface_EntityIterator& iter, const Standard_Integer newstat)
{
if(thestats.IsNull())
return;
for (iter.Start(); iter.More(); iter.Next()) {
Handle(Standard_Transient) ent = iter.Value();
Standard_Integer num = EntityNumber(ent);
if (num == 0) continue;
if (theflags.CTrue(num,Graph_Present)) continue;
thestats.SetValue(num,newstat);
if (!num)
continue;
if (theflags.CTrue(num,Graph_Present))
continue;
thestats->SetValue(num,newstat);
}
}
void Interface_Graph::GetFromIter
(const Interface_EntityIterator& iter,
const Standard_Integer newstat, const Standard_Integer overlapstat,
const Standard_Boolean cumul)
void Interface_Graph::GetFromIter
(const Interface_EntityIterator& iter,
const Standard_Integer newstat, const Standard_Integer overlapstat,
const Standard_Boolean cumul)
{
if(thestats.IsNull())
return;
for (iter.Start(); iter.More(); iter.Next()) {
Handle(Standard_Transient) ent = iter.Value();
Standard_Integer num = EntityNumber(ent);
if (num == 0) continue;
if (!num)
continue;
/*Standard_Boolean pasla = !*/theflags.Value(num,Graph_Present);
/*Standard_Integer stat = */thestats.Value(num);
/*Standard_Integer stat = */thestats->Value(num);
GetFromEntity (ent,Standard_False,newstat,overlapstat,cumul);
}
}
void Interface_Graph::GetFromGraph (const Interface_Graph& agraph)
void Interface_Graph::GetFromGraph (const Interface_Graph& agraph)
{
if (Model() != agraph.Model()) Standard_DomainError::Raise
("Graph from Interface : GetFromGraph");
@ -385,8 +351,8 @@
}
}
void Interface_Graph::GetFromGraph
(const Interface_Graph& agraph, const Standard_Integer stat)
void Interface_Graph::GetFromGraph
(const Interface_Graph& agraph, const Standard_Integer stat)
{
if (Model() != agraph.Model()) Standard_DomainError::Raise
("Graph from Interface : GetFromGraph");
@ -401,280 +367,109 @@
// .... Listage des Entites Partagees ....
Standard_Boolean Interface_Graph::HasShareErrors
(const Handle(Standard_Transient)& ent) const
Standard_Boolean Interface_Graph::HasShareErrors
(const Handle(Standard_Transient)& ent) const
{
if(thestats.IsNull())
return Standard_False;
Standard_Integer num = EntityNumber(ent);
if (num == 0) return Standard_True;
return theflags.Value (num,Graph_ShareError);
}
// A chaque entite, on peut attacher une Liste de numeros d entites partagees
// Si elle est nulle, BasicShareds convient, sinon on prend RedefinedShareds
Standard_Boolean Interface_Graph::HasRedefinedShareds
(const Handle(Standard_Transient)& ent) const
Interface_EntityIterator Interface_Graph::Shareds
(const Handle(Standard_Transient)& ent) const
{
Standard_Integer num = EntityNumber(ent);
if (num == 0) return Standard_False;
return thesharnews.IsRedefined (num);
}
Interface_EntityIterator Interface_Graph::Shareds
(const Handle(Standard_Transient)& ent) const
{
Standard_Integer num = EntityNumber(ent);
if (num == 0) Standard_DomainError::Raise ("Interface : Shareds");
Interface_EntityIterator iter;
Interface_IntList list = thesharnews;
if (!list.IsRedefined(num)) list = theshareds;
list.SetNumber (num);
Standard_Integer nb = list.Length();
for (Standard_Integer i = 1; i <= nb; i ++)
iter.GetOneItem (themodel->Value (list.Value(i) ));
Standard_Integer num = EntityNumber(ent);
if(!num)
return iter;
Handle(Standard_Transient) aCurEnt = ent;
if (themodel->IsRedefinedContent(num))
aCurEnt = themodel->ReportEntity(num)->Content();
//if (num == 0) Standard_DomainError::Raise ("Interface : Shareds");
Handle(Interface_GeneralModule) module;
Standard_Integer CN;
if (themodel->GTool()->Select(aCurEnt,module,CN))
module->FillShared(themodel,CN,aCurEnt,iter);
return iter;
}
Interface_IntList Interface_Graph::SharedNums
(const Standard_Integer num) const
Handle(TColStd_HSequenceOfTransient) Interface_Graph::GetShareds(const Handle(Standard_Transient)& ent) const
{
Interface_IntList list = thesharnews;
if (!list.IsRedefined(num)) list = theshareds;
list.SetNumber (num);
return list;
Handle(TColStd_HSequenceOfTransient) aseq = new TColStd_HSequenceOfTransient;
Interface_EntityIterator iter = Shareds(ent);
for( ; iter.More(); iter.Next())
aseq->Append(iter.Value());
return aseq;
}
Interface_EntityIterator Interface_Graph::Sharings
(const Handle(Standard_Transient)& ent) const
Handle(TColStd_HSequenceOfTransient) Interface_Graph::GetSharings(const Handle(Standard_Transient)& ent) const
{
Standard_Integer num = EntityNumber(ent);
if (num == 0) Standard_DomainError::Raise ("Interface : Sharings");
Interface_EntityIterator iter;
Interface_IntList list = thesharings; list.SetNumber (num);
Standard_Integer nb = list.Length();
for (Standard_Integer i = 1; i <= nb; i ++)
iter.GetOneItem (themodel->Value(list.Value(i)));
return iter;
if(!num)
return 0;
//return Handle(TColStd_HSequenceOfTransient)::DownCast(thesharings->Value(num));
const TColStd_ListOfInteger& alist = thesharings->Value(num);
Handle(TColStd_HSequenceOfTransient) aSharings = new TColStd_HSequenceOfTransient;
TColStd_ListIteratorOfListOfInteger aIt(alist);
for( ; aIt.More() ; aIt.Next())
aSharings->Append(Entity(aIt.Value()));
return aSharings;
}
Interface_IntList Interface_Graph::SharingNums
(const Standard_Integer num) const
Interface_EntityIterator Interface_Graph::Sharings
(const Handle(Standard_Transient)& ent) const
{
Interface_IntList list = thesharings;
if (num > 0) list.SetNumber (num);
return list;
}
Interface_EntityIterator iter;
iter.AddList(GetSharings(ent));
return iter;
}
static void AddTypedSharings
(const Handle(Standard_Transient)& ent, const Handle(Standard_Type)& type,
Interface_EntityIterator& iter, const Standard_Integer n,
const Interface_Graph& G)
(const Handle(Standard_Transient)& ent, const Handle(Standard_Type)& type,
Interface_EntityIterator& iter, const Standard_Integer n,
const Interface_Graph& G)
{
if (ent.IsNull()) return;
if (ent->IsKind(type)) { iter.AddItem (ent); return; }
if (iter.NbEntities() > n) return;
Interface_IntList list = G.SharingNums(G.EntityNumber(ent));
Standard_Integer nb = list.Length();
Handle(TColStd_HSequenceOfTransient) list = G.GetSharings(ent);
if(list.IsNull())
return;
Standard_Integer nb = list->Length();
for (Standard_Integer i = 1; i <= nb; i ++)
AddTypedSharings (G.Entity(list.Value(i)) ,type,iter,nb,G);
AddTypedSharings (list->Value(i) ,type,iter,nb,G);
}
Interface_EntityIterator Interface_Graph::TypedSharings
(const Handle(Standard_Transient)& ent, const Handle(Standard_Type)& type) const
Interface_EntityIterator Interface_Graph::TypedSharings
(const Handle(Standard_Transient)& ent, const Handle(Standard_Type)& type) const
{
Interface_EntityIterator iter;
Standard_Integer n = Size();
AddTypedSharings (ent,type,iter,n,*this);
return iter;
}
Interface_EntityIterator Interface_Graph::RootEntities () const
Interface_EntityIterator Interface_Graph::RootEntities () const
{
Interface_EntityIterator iter;
Standard_Integer nb = Size();
Interface_IntList list (thesharings);
Standard_Integer nb = thesharings->Length();
for (Standard_Integer i = 1; i <= nb; i ++) {
list.SetNumber (i);
if (list.Length() == 0) iter.GetOneItem (themodel->Value(i));
if(!thesharings->Value(i).IsEmpty())
continue;
iter.AddItem(Entity(i));
}
return iter;
}
// ######################################################################
// .... Redefinition des listes Shared-Sharing ....
void Interface_Graph::SetShare
(const Handle(Standard_Transient)& ent)
{
Standard_Integer num = EntityNumber(ent);
if (num == 0) return;
SetShare (ent,SharedNums(num));
}
void Interface_Graph::SetShare
(const Handle(Standard_Transient)& ent,
const Interface_EntityIterator& list)
{
if(!thesharnews.NbEntities())
thesharnews.Initialize(themodel->NbEntities());
Standard_Integer num = EntityNumber(ent);
if (num == 0) return;
thesharnews.SetNumber (num);
thesharnews.SetRedefined (Standard_True);
thesharnews.Reservate (list.NbEntities());
for (list.Start(); list.More(); list.Next()) {
Standard_Integer nsh = EntityNumber(list.Value());
if (nsh != 0) thesharnews.Add (nsh);
}
}
void Interface_Graph::SetShare
(const Handle(Standard_Transient)& ent, const Interface_IntList& list)
{
Standard_Integer num = EntityNumber(ent);
if (num == 0) return;
if(!thesharnews.NbEntities())
thesharnews.Initialize(themodel->NbEntities());
Standard_Integer i, n = list.Length();
thesharnews.SetNumber (num);
thesharnews.SetRedefined (Standard_True);
thesharnews.Reservate (n);
for (i = 1; i <= n; i ++) {
Standard_Integer nsh = list.Value(i);
if (nsh != 0) thesharnews.Add (nsh);
}
}
void Interface_Graph::SetNoShare
(const Handle(Standard_Transient)& ent)
{
Standard_Integer num = EntityNumber(ent);
if (num == 0) return;
if(!thesharnews.NbEntities()) return;
thesharnews.SetNumber (num);
thesharnews.SetRedefined (Standard_False);
}
void Interface_Graph::SetNoShare (const Interface_EntityIterator& list)
{
for (list.Start(); list.More(); list.Next()) SetNoShare(list.Value());
}
void Interface_Graph::AddShared
(const Handle(Standard_Transient)& ent,
const Handle(Standard_Transient)& shared)
{
//Standard_Integer i, nb; svv Feb21 2000 : porting on SIL
Standard_Integer num = EntityNumber(ent);
Standard_Integer nsh = EntityNumber(shared);
if (!thesharnews.IsRedefined(num) || num == 0 || nsh == 0) Standard_DomainError::Raise
("Interface Graph : AddShared, cannot be applied");
if(!thesharnews.NbEntities())
thesharnews.Initialize(themodel->NbEntities());
// Liste Shared(ent)
thesharnews.SetNumber (num);
thesharnews.Reservate (thesharnews.Length()+1);
thesharnews.Add (nsh);
// Liste Sharing(shared)
thesharings.SetNumber (nsh);
thesharings.Reservate (thesharings.Length()+1);
thesharings.Add (num);
}
void Interface_Graph::RemoveShared
(const Handle(Standard_Transient)& ent,
const Handle(Standard_Transient)& shared)
{
Standard_Integer num = EntityNumber(ent);
Standard_Integer nsh = EntityNumber(shared);
if (!thesharnews.IsRedefined(num) || num == 0 || nsh == 0) Standard_DomainError::Raise
("Interface Graph : RemoveShared, cannot be applied");
// Liste Shared (ent)
if(!thesharnews.NbEntities())
thesharnews.Initialize(themodel->NbEntities());
thesharnews.SetNumber (num);
Standard_Integer i,nbsh = thesharnews.Length();
for (i = nbsh; i > 0; i --)
if (thesharnews.Value(i) == nsh) thesharnews.Remove(i);
// Liste Sharing (shared)
thesharings.SetNumber (nsh);
nbsh = thesharings.Length();
for (i = nbsh; i > 0; i --)
if (thesharings.Value(i) == num) thesharings.Remove(i);
}
void Interface_Graph::ResetShare
(const Handle(Standard_Transient)& ent)
{
Standard_Integer num = EntityNumber(ent);
if (num == 0) return;
Interface_IntList snew(thesharnews);
if (!thesharnews.NbEntities() || !snew.IsRedefined(num)) return;
snew.SetNumber (num);
Interface_IntList sold(theshareds);
sold.SetNumber (num);
// Attention aux Sharings ... Il va falloir ajouter, supprimer ... laisser !
// Tableau // Entites : 0 hors jeu 1 reapparait 2 disparait 3 reste
Standard_Integer n = Size();
TColStd_Array1OfInteger oldnew(1,n); oldnew.Init(0);
Standard_Integer ns = sold.Length();
Standard_Integer i; // svv Jan11 2000 : porting on DEC
for (i = 1; i <= ns; i ++)
oldnew.SetValue(sold.Value(i),1); // pourra passer en 3 plus tard ...
ns = snew.Length();
for (i = 1; i <= ns; i ++) {
Standard_Integer oldstat = oldnew.Value(snew.Value(i));
oldnew.SetValue(snew.Value(i),oldstat+2); // 0 -> 2, 1 -> 3
}
// Muni de ces donnees, on pourra modifier les listes Sharings impliquees
for (i = 1; i <= n; i ++) {
Standard_Integer oldstat = oldnew.Value(snew.Value(i));
if (oldstat == 0 || oldstat == 2) continue;
thesharings.SetNumber(i);
if (oldstat == 1) {
thesharings.Reservate (thesharings.Length()+1);
thesharings.Add (num);
} else if (oldstat == 3) {
Standard_Integer j,nbsh = thesharings.Length();
for (j = nbsh; j > 0; j --)
if (thesharings.Value(j) == num) thesharings.Remove(j);
}
}
// Shared : beaucoup plus simple, ANNULER Redefined
thesharnews.SetRedefined (Standard_False);
}
void Interface_Graph::ResetAllShare ()
{
thesharnews.Clear();
EvalSharings();
}
Handle(TCollection_HAsciiString) Interface_Graph::Name
(const Handle(Standard_Transient)& ent) const
Handle(TCollection_HAsciiString) Interface_Graph::Name(const Handle(Standard_Transient)& ent) const
{
Handle(TCollection_HAsciiString) str;
if (themodel.IsNull()) return str;
@ -690,3 +485,8 @@ static void AddTypedSharings
Interface_ShareTool sht (*this);
return module->Name (CN,ent,sht);
}
Standard_Boolean Interface_Graph::ModeStat() const
{
return (!thestats.IsNull());
}

13
src/Interface/Interface_GraphContent.cxx
View File

@ -17,14 +17,13 @@
Interface_GraphContent::Interface_GraphContent
(const Interface_Graph& agraph, const Handle(Standard_Transient)& ent)
{
Interface_IntList list =
agraph.SharedNums(agraph.EntityNumber(ent));
Standard_Integer nb = list.Length();
Interface_EntityIterator list = agraph.Shareds(ent);
Standard_Integer nb = list.NbEntities();
if (nb == 0) return; // Liste redefinie a VIDE
Handle(Interface_InterfaceModel) mod = agraph.Model();
for (Standard_Integer i = 1; i <= nb; i ++) {
Standard_Integer num = list.Value(i);
if (agraph.IsPresent(num)) GetOneItem (agraph.Entity(num));
for( ; list.More(); list.Next()) {
Handle(Standard_Transient) curent = list.Value();
if (agraph.IsPresent(agraph.EntityNumber(curent)))
GetOneItem (curent);
}
}

14
src/Interface/Interface_HGraph.cdl
View File

@ -20,21 +20,25 @@ is
Create (agraph : Graph) returns mutable HGraph;
---Purpose : Creates an HGraph directly from a Graph.
-- Remark that the starting Graph is duplicated
Create (amodel : InterfaceModel; lib : GeneralLib) returns mutable HGraph;
Create (amodel : InterfaceModel; lib : GeneralLib;
theModeStats : Boolean = Standard_True) returns mutable HGraph;
---Purpose : Creates an HGraph with a Graph created from <amodel> and <lib>
Create (amodel : InterfaceModel; protocol : Protocol from Interface)
Create (amodel : InterfaceModel; protocol : Protocol from Interface;
theModeStats : Boolean = Standard_True)
returns mutable HGraph;
---Purpose : Creates an HGraph with a graph itself created from <amodel>
-- and <protocol>
Create (amodel : InterfaceModel; gtool : GTool from Interface)
Create (amodel : InterfaceModel; gtool : GTool from Interface;
theModeStats : Boolean = Standard_True)
returns mutable HGraph;
---Purpose : Creates an HGraph with a graph itself created from <amodel>
-- and <protocol>
Create (amodel : InterfaceModel) returns mutable HGraph
Create (amodel : InterfaceModel;
theModeStats : Boolean = Standard_True) returns mutable HGraph
---Purpose : Same a above, but works with the GTool in the model
raises DomainError;
-- Error if no Active Protocol is defined

25
src/Interface/Interface_HGraph.cxx
View File

@ -1,32 +1,35 @@
#include <Interface_HGraph.ixx>
Interface_HGraph::Interface_HGraph (const Interface_Graph& agraph)
Interface_HGraph::Interface_HGraph (const Interface_Graph& agraph)
: thegraph(agraph) { }
Interface_HGraph::Interface_HGraph
(const Handle(Interface_InterfaceModel)& amodel,
const Interface_GeneralLib& lib)
: thegraph (amodel,lib) { }
const Interface_GeneralLib& lib,
const Standard_Boolean theModeStat)
: thegraph (amodel,lib,theModeStat) { }
Interface_HGraph::Interface_HGraph
(const Handle(Interface_InterfaceModel)& amodel,
const Handle(Interface_Protocol)& protocol)
: thegraph (amodel,protocol) { }
const Handle(Interface_Protocol)& protocol,
const Standard_Boolean theModeStat)
: thegraph (amodel,protocol,theModeStat) { }
Interface_HGraph::Interface_HGraph
(const Handle(Interface_InterfaceModel)& amodel,
const Handle(Interface_GTool)& gtool)
: thegraph (amodel,gtool) { }
const Handle(Interface_GTool)& gtool,
const Standard_Boolean theModeStat)
: thegraph (amodel,gtool,theModeStat) { }
Interface_HGraph::Interface_HGraph
(const Handle(Interface_InterfaceModel)& amodel)
: thegraph (amodel) { }
(const Handle(Interface_InterfaceModel)& amodel,
const Standard_Boolean theModeStat)
: thegraph (amodel,theModeStat) { }
const Interface_Graph& Interface_HGraph::Graph () const

28
src/Interface/Interface_ShareFlags.cxx
View File

@ -46,19 +46,21 @@
}
Interface_ShareFlags::Interface_ShareFlags (const Interface_Graph& agraph)
: theflags (agraph.Model()->NbEntities())
{
themodel = agraph.Model();
Standard_Integer nb = themodel->NbEntities();
if (nb == 0) return;
theroots = new TColStd_HSequenceOfTransient();
for (Standard_Integer i = 1; i <= nb; i ++) {
// Resultat obtenu depuis le Graph
Interface_IntList list = agraph.SharingNums(i);
if (list.Length() > 0) theflags.SetTrue(i);
else theroots->Append (themodel->Value(i));
}
}
: theflags (agraph.Model()->NbEntities())
{
themodel = agraph.Model();
Standard_Integer nb = themodel->NbEntities();
if (nb == 0) return;
theroots = new TColStd_HSequenceOfTransient();
for (Standard_Integer i = 1; i <= nb; i ++) {
// Resultat obtenu depuis le Graph
Handle(Standard_Transient) ent = themodel->Value(i);
Handle(TColStd_HSequenceOfTransient) list = agraph.GetSharings(ent);
if (!list.IsNull() && list->Length() > 0) theflags.SetTrue(i);
else theroots->Append (ent);
}
}
void Interface_ShareFlags::Evaluate

2
src/Interface/Interface_ShareTool.cdl
View File

@ -46,7 +46,7 @@ is
Create (ahgraph : HGraph) returns ShareTool;
AddImplied (me : in out; gtool : GTool from Interface);
--AddImplied (me : in out; gtool : GTool from Interface);
---Purpose : Completes the Graph by Adding Implied References. Hence, they
-- are considered as Sharing References in all the other queries

36
src/Interface/Interface_ShareTool.cxx
View File

@ -31,15 +31,16 @@ Interface_ShareTool::Interface_ShareTool (const Handle(Interface_InterfaceModel)
Interface_ShareTool::Interface_ShareTool (const Interface_Graph& agraph)
{
theHGraph = new Interface_HGraph(agraph);
theHGraph = new Interface_HGraph(agraph.Model());
}
Interface_ShareTool::Interface_ShareTool (const Handle(Interface_HGraph)& ahgraph)
: theHGraph(ahgraph)
{}
{
theHGraph = ahgraph;
}
// Ajout des "Implied" sur toutes les Entites du Graphe
void Interface_ShareTool::AddImplied (const Handle(Interface_GTool)& gtool)
/*void Interface_ShareTool::AddImplied (const Handle(Interface_GTool)& gtool)
{
Interface_Graph& thegraph = theHGraph->CGraph();
Standard_Integer nb = thegraph.Size();
@ -59,7 +60,7 @@ void Interface_ShareTool::AddImplied (const Handle(Interface_GTool)& gtool)
}
}
if (yena) thegraph.EvalSharings();
}
}*/
Handle(Interface_InterfaceModel) Interface_ShareTool::Model () const
@ -75,9 +76,9 @@ void Interface_ShareTool::AddImplied (const Handle(Interface_GTool)& gtool)
(const Handle(Standard_Transient)& ent) const
{
const Interface_Graph& thegraph = theHGraph->Graph();
Interface_IntList list =
thegraph.SharingNums (thegraph.EntityNumber(ent));
return (list.Length() > 0);
Handle(TColStd_HSequenceOfTransient) list =
thegraph.GetShareds (ent);
return (!list.IsNull() && list->Length() > 0);
}
Interface_EntityIterator Interface_ShareTool::Shareds
@ -94,12 +95,14 @@ void Interface_ShareTool::AddImplied (const Handle(Interface_GTool)& gtool)
const Handle(Standard_Type)& atype) const
{
Interface_Graph& thegraph = theHGraph->CGraph();
Interface_IntList list =
thegraph.SharingNums (thegraph.EntityNumber(ent));
Handle(TColStd_HSequenceOfTransient) list = thegraph.GetSharings (ent);
if(list.IsNull())
return 0;
Standard_Integer result = 0;
Standard_Integer n = list.Length();
Standard_Integer n = list->Length();
for (Standard_Integer i = 1; i <= n; i ++) {
Handle(Standard_Transient) entsh = thegraph.Entity(list.Value(i));
Handle(Standard_Transient) entsh = list->Value(i);
if (entsh.IsNull()) continue;
if (entsh->IsKind(atype)) result ++;
}
@ -111,13 +114,14 @@ void Interface_ShareTool::AddImplied (const Handle(Interface_GTool)& gtool)
const Handle(Standard_Type)& atype) const
{
Interface_Graph& thegraph = theHGraph->CGraph();
Interface_IntList list =
thegraph.SharingNums (thegraph.EntityNumber(ent));
Handle(TColStd_HSequenceOfTransient) list = thegraph.GetSharings(ent);
if(list.IsNull())
return 0;
Handle(Standard_Transient) entresult;
Standard_Integer result = 0;
Standard_Integer n = list.Length();
Standard_Integer n = list->Length();
for (Standard_Integer i = 1; i <= n; i ++) {
Handle(Standard_Transient) entsh = thegraph.Entity(list.Value(i));
Handle(Standard_Transient) entsh = list->Value(i);
if (entsh.IsNull()) continue;
if (entsh->IsKind(atype)) {
entresult = entsh;

8
src/StepData/StepData_StepModel.cdl
View File

@ -13,7 +13,7 @@ class StepModel from StepData inherits InterfaceModel
uses Type, HAsciiString from TCollection,
Messenger from Message,
DataMapOfTransientInteger,
HArray1OfInteger from TColStd,
EntityList, EntityIterator, Check
raises NoSuchObject
@ -22,9 +22,7 @@ is
Create returns mutable StepModel;
---Purpose: Creates an empty STEP model with an empty header.
Reservate (me : mutable; nbent : Integer) is redefined;
---Purpose : The standard reservation is completed for the map (id-num)
Entity (me; num : Integer) returns Transient;
---Purpose : returns entity given its rank.
-- Same as InterfaceEntity, but with a shorter name
@ -87,6 +85,6 @@ is
fields
theheader : EntityList;
theidnums : DataMapOfTransientInteger;
theidnums : HArray1OfInteger from TColStd;
end StepModel;

106
src/StepData/StepData_StepModel.cxx
View File

@ -14,26 +14,21 @@
// Entete de fichier : liste d entites
StepData_StepModel::StepData_StepModel () { }
StepData_StepModel::StepData_StepModel () { }
void StepData_StepModel::Reservate (const Standard_Integer nbent)
{
Interface_InterfaceModel::Reservate(nbent);
if (nbent > theidnums.NbBuckets()) theidnums.ReSize (nbent);
}
Handle(Standard_Transient) StepData_StepModel::Entity
(const Standard_Integer num) const
{ return Value(num); } // nom plus joli
Handle(Standard_Transient) StepData_StepModel::Entity
(const Standard_Integer num) const
{ return Value(num); } // nom plus joli
void StepData_StepModel::GetFromAnother
(const Handle(Interface_InterfaceModel)& other)
void StepData_StepModel::GetFromAnother
(const Handle(Interface_InterfaceModel)& other)
{
theheader.Clear();
DeclareAndCast(StepData_StepModel,another,other);
if (another.IsNull()) return;
Interface_EntityIterator iter = another->Header();
// recopier le header. Attention, header distinct du contenu ...
// recopier le header. Attention, header distinct du contenu ...
Interface_CopyTool TC (this,StepData::HeaderProtocol());
for (; iter.More(); iter.Next()) {
Handle(Standard_Transient) newhead;
@ -42,35 +37,35 @@
}
}
Handle(Interface_InterfaceModel) StepData_StepModel::NewEmptyModel () const
{ return new StepData_StepModel; }
Handle(Interface_InterfaceModel) StepData_StepModel::NewEmptyModel () const
{ return new StepData_StepModel; }
Interface_EntityIterator StepData_StepModel::Header () const
Interface_EntityIterator StepData_StepModel::Header () const
{
Interface_EntityIterator iter;
theheader.FillIterator(iter);
return iter;
}
Standard_Boolean StepData_StepModel::HasHeaderEntity
(const Handle(Standard_Type)& atype) const
{ return (theheader.NbTypedEntities(atype) == 1); }
Standard_Boolean StepData_StepModel::HasHeaderEntity
(const Handle(Standard_Type)& atype) const
{ return (theheader.NbTypedEntities(atype) == 1); }
Handle(Standard_Transient) StepData_StepModel::HeaderEntity
(const Handle(Standard_Type)& atype) const
{ return theheader.TypedEntity(atype); }
Handle(Standard_Transient) StepData_StepModel::HeaderEntity
(const Handle(Standard_Type)& atype) const
{ return theheader.TypedEntity(atype); }
// Remplissage du Header
void StepData_StepModel::ClearHeader ()
{ theheader.Clear(); }
void StepData_StepModel::ClearHeader ()
{ theheader.Clear(); }
void StepData_StepModel::AddHeaderEntity
(const Handle(Standard_Transient)& ent)
{ theheader.Append(ent); }
void StepData_StepModel::AddHeaderEntity
(const Handle(Standard_Transient)& ent)
{ theheader.Append(ent); }
void StepData_StepModel::VerifyCheck(Handle(Interface_Check)& ach) const
@ -86,10 +81,10 @@ void StepData_StepModel::VerifyCheck(Handle(Interface_Check)& ach) const
}
void StepData_StepModel::DumpHeader
(const Handle(Message_Messenger)& S, const Standard_Integer /*level*/) const
void StepData_StepModel::DumpHeader
(const Handle(Message_Messenger)& S, const Standard_Integer /*level*/) const
{
// NB : level n est pas utilise
// NB : level n est pas utilise
Handle(StepData_Protocol) stepro = StepData::HeaderProtocol();
Standard_Boolean iapro = !stepro.IsNull();
@ -114,45 +109,50 @@ void StepData_StepModel::VerifyCheck(Handle(Interface_Check)& ach) const
}
void StepData_StepModel::ClearLabels ()
{ theidnums.Clear(); }
void StepData_StepModel::ClearLabels ()
{ theidnums.Nullify(); }
void StepData_StepModel::SetIdentLabel
(const Handle(Standard_Transient)& ent, const Standard_Integer ident)
void StepData_StepModel::SetIdentLabel
(const Handle(Standard_Transient)& ent, const Standard_Integer ident)
{
if (Number(ent) == 0) return;
if (theidnums.NbBuckets() < NbEntities()) theidnums.ReSize (NbEntities());
if (theidnums.IsBound(ent)) theidnums.ChangeFind(ent) = ident;
else theidnums.Bind (ent,ident);
Standard_Integer num = Number(ent);
if (!num)
return;
if(theidnums.IsNull())
{
theidnums = new TColStd_HArray1OfInteger(1, NbEntities());
theidnums->Init(0);
}
theidnums->SetValue(num,ident);
}
Standard_Integer StepData_StepModel::IdentLabel
(const Handle(Standard_Transient)& ent) const
Standard_Integer StepData_StepModel::IdentLabel
(const Handle(Standard_Transient)& ent) const
{
if (theidnums.IsBound(ent)) return theidnums.Find(ent);
return 0;
}
if(theidnums.IsNull())
return 0;
Standard_Integer num = Number(ent);
return (!num ? 0 : theidnums->Value(num));
}
void StepData_StepModel::PrintLabel
(const Handle(Standard_Transient)& ent, const Handle(Message_Messenger)& S) const
void StepData_StepModel::PrintLabel
(const Handle(Standard_Transient)& ent, const Handle(Message_Messenger)& S) const
{
Standard_Integer num = 0 , nid = 0;
if (theidnums.IsBound(ent)) nid = theidnums.Find(ent);
if (nid <= 0) num = Number(ent);
Standard_Integer num = (theidnums.IsNull() ? 0 : Number(ent));
Standard_Integer nid = (!num ? 0 : theidnums->Value(num));
if (nid > 0) S<<"#"<<nid;
else if (num > 0) S<<"(#"<<num<<")";
else S<<"(#0..)";
}
Handle(TCollection_HAsciiString) StepData_StepModel::StringLabel
(const Handle(Standard_Transient)& ent) const
Handle(TCollection_HAsciiString) StepData_StepModel::StringLabel
(const Handle(Standard_Transient)& ent) const
{
Handle(TCollection_HAsciiString) label;
char text[20];
Standard_Integer num = 0 , nid = 0;
if (theidnums.IsBound(ent)) nid = theidnums.Find(ent);
if (nid <= 0) num = Number(ent);
Standard_Integer num = (theidnums.IsNull() ? 0 : Number(ent));
Standard_Integer nid = (!num ? 0 : theidnums->Value(num));
if (nid > 0) sprintf (text, "#%d",nid);
else if (num > 0) sprintf (text, "(#%d)",num);

6
src/StepFile/StepFile_Read.cxx
View File

@ -190,6 +190,7 @@ Standard_Integer StepFile_Read
readtool.PrepareHeader(recoheader); // Header. reco nul -> pour Protocol
readtool.Prepare(recodata); // Data. reco nul -> pour Protocol
#ifdef CHRONOMESURE
sout << " ... Parameters prepared ... ";
c.Show();
@ -198,13 +199,16 @@ Standard_Integer StepFile_Read
readtool.LoadModel(stepmodel);
if (stepmodel->Protocol().IsNull()) stepmodel->SetProtocol (protocol);
lir_file_fin(2);
readtool.Clear();
undirec.Nullify();
#ifdef CHRONOMESURE
sout << " ... Objets analysed ... " << endl;
c.Show();
n = stepmodel->NbEntities() ;
sout << " STEP Loading done : " << n << " Entities" << endl;
#endif
stepread_endinput (newin,ficnom); return 0 ;
}

2
src/Transfer/Transfer_TransientProcess.cxx
View File

@ -45,6 +45,8 @@ void Transfer_TransientProcess::SetGraph(const Handle(Interface_HGraph)& HG)
thegraph = HG;
if (!thegraph.IsNull())
SetModel(thegraph->Graph().Model());
else
themodel.Nullify();
}

41
src/XSControl/XSControl_TransferReader.cxx
View File

@ -40,19 +40,6 @@
#include <ShapeFix.hxx>
#include <stdio.h>
/*
#ifdef DEB
static void monDBPE
(const Handle(Message_Messenger)& S, const Handle(Standard_Transient)& ent, const Handle(Standard_Transient)& context)
{
if (ent.IsNull()) { S<<"(null)"; return; }
DeclareAndCast(Interface_InterfaceModel,model,context);
if (model.IsNull()) { S<<ent->DynamicType()->Name(); return; }
model->Print (ent,S);
S<<" "<<model->TypeName(ent,Standard_False);
}
#endif
*/
//=======================================================================
//function : XSControl_TransferReader
@ -121,9 +108,15 @@ void XSControl_TransferReader::SetModel(const Handle(Interface_InterfaceModel)&
void XSControl_TransferReader::SetGraph(const Handle(Interface_HGraph)& graph)
{
if (graph.IsNull()) return;
if (graph.IsNull())
{
theModel.Nullify();
}
else
theModel = graph->Graph().Model();
theGraph = graph;
theModel = graph->Graph().Model();
if (!theTransfer.IsNull()) theTransfer->SetGraph(graph);
}
@ -221,7 +214,7 @@ void XSControl_TransferReader::Clear (const Standard_Integer mode)
theTransfer.Nullify();
theActor.Nullify();
theFilename.Clear();
} // theContext.Nullify();
}
}
@ -868,9 +861,7 @@ Standard_Integer XSControl_TransferReader::TransferOne
Handle(Message_Messenger) sout = theTransfer->Messenger();
Standard_Integer level = theTransfer->TraceLevel();
//BRepBuilderAPI::Precision (Interface_Static::RVal("read.precision.val")); //szv#11:CASCADE30:01Feb00
//Interface_Static::SetRVal("lastpreci",0.0);
Transfer_TransferOutput TP (theTransfer,theModel);
if (theGraph.IsNull()) theTransfer->SetModel(theModel);
@ -925,8 +916,6 @@ Standard_Integer XSControl_TransferReader::TransferList
Handle(Message_Messenger) sout = theTransfer->Messenger();
Standard_Integer level = theTransfer->TraceLevel();
//BRepBuilderAPI::Precision (Interface_Static::RVal("read.precision.val")); //szv#11:CASCADE30:01Feb00
//Interface_Static::SetRVal("lastpreci",0.0);
Transfer_TransferOutput TP (theTransfer,theModel);
if (theGraph.IsNull()) theTransfer->SetModel(theModel);
else theTransfer->SetGraph(theGraph);
@ -984,8 +973,6 @@ Standard_Integer XSControl_TransferReader::TransferRoots(const Interface_Graph&
Handle(Message_Messenger) sout = theTransfer->Messenger();
Standard_Integer level = theTransfer->TraceLevel();
//BRepBuilderAPI::Precision (Interface_Static::RVal("read.precision.val")); //szv#11:CASCADE30:01Feb00
//Interface_Static::SetRVal("lastpreci",0.0);
Transfer_TransferOutput TP (theTransfer,theModel);
if (theGraph.IsNull()) theTransfer->SetModel(theModel);
else theTransfer->SetGraph(theGraph);
@ -1035,15 +1022,9 @@ void XSControl_TransferReader::TransferClear(const Handle(Standard_Transient)& e
if (theTransfer.IsNull()) return;
if (ent == theModel) { theTransfer->Clear(); return; }
//// if (level > 0) list = TransferredList (list);
// Standard_Integer i, nb = list->Length();
// theTransfer->ComputeScopes();
// for (i = 1; i <= nb; i ++) {
// Handle(Standard_Transient) ent = list->Value(i);
// theTransfer->Unbind (ent);
theTransfer->RemoveResult (ent,level);
ClearResult (ent,-1);
// }
}

35
src/XSControl/XSControl_WorkSession.cxx
View File

@ -282,32 +282,7 @@ Standard_Boolean XSControl_WorkSession::PrintTransferStatus(const Standard_Inte
binder = TP->MapItem (ne);
S<<endl;
TP->StartTrace (binder,ent,0,0);
/*skl
if (!binder.IsNull()) {
// infos complementaires : cas et attributs
Standard_Integer icas, nbcas = binder->NbCases();
if (nbcas > 0) S<<"Recorded Cases : "<<nbcas<<" :";
for (icas = 1; icas <= nbcas; icas ++) S<<" "<<binder->CaseName(icas);
if (nbcas > 0) S<<endl;
Standard_Integer nbatr = 0;
Handle(Dico_DictionaryOfTransient) atrs = binder->AttrList();
Dico_IteratorOfDictionaryOfTransient iatr (atrs);
for (; iatr.More(); iatr.Next()) {
Handle(Standard_Transient) atr = iatr.Value();
if (atr.IsNull()) continue;
if (nbatr == 0) S<<"-- List of Attributes"<<endl;
nbatr ++;
S<<iatr.Name()<<" : ";
DeclareAndCast(Interface_IntVal,intatr,atr);
if (!intatr.IsNull()) S<<"Integer="<<intatr->Value();
DeclareAndCast(Geom2d_Point,realtr,atr);
if (!realtr.IsNull()) S<<"Real="<<realtr->X();
if (intatr.IsNull() && realtr.IsNull()) S<<"Type:"<<atr->DynamicType()->Name();
S<<endl;
}
if (nbatr > 0) S<<"-- Total of Attributes : "<<nbatr<<endl;
}
skl*/
}
// *** CHECK (commun READ+WRITE) ***
@ -471,8 +446,6 @@ Handle(Standard_Transient) XSControl_WorkSession::Result
Standard_Integer XSControl_WorkSession::TransferReadOne
(const Handle(Standard_Transient)& ent)
{
//Standard_OStream& sout = Interface_TraceFile::Def();
//Standard_Integer level = Interface_TraceFile::DefLevel();
Handle(Interface_InterfaceModel) model = Model();
if (ent == model) return TransferReadRoots();
@ -507,8 +480,14 @@ Handle(Interface_InterfaceModel) XSControl_WorkSession::NewModel ()
Handle(Interface_InterfaceModel) newmod;
if (theController.IsNull()) return newmod;
newmod = theController->NewModel();
SetModel(newmod);
if(!MapReader().IsNull())
MapReader()->Clear();
//clear all contains of WS
theTransferRead->Clear(3);
theTransferWrite->Clear(-1);
return newmod;
}

2
src/XSDRAWIGES/XSDRAWIGES.cxx
View File

@ -85,6 +85,8 @@ static Standard_Integer igesbrep (Draw_Interpretor& di, Standard_Integer argc, c
progress->Show();
IGESControl_Reader Reader (XSDRAW::Session(),Standard_False);
Standard_Boolean aFullMode = Standard_True;
Reader.WS()->SetModeStat(aFullMode);
if (ctl.IsNull())
ctl=Handle(IGESControl_Controller)::DownCast(XSDRAW::Controller());

128
src/XSDRAWSTEP/XSDRAWSTEP.cxx
View File

@ -81,15 +81,16 @@ void XSDRAWSTEP::Init ()
static Standard_Integer stepread (Draw_Interpretor& di/*theCommands*/, Standard_Integer argc, const char** argv)
{
// On admet le controller AP214 ou une variante
// On admet le controller AP214 ou une variante
DeclareAndCast(STEPControl_Controller,ctl,XSDRAW::Controller());
if (ctl.IsNull()) XSDRAW::SetNorm("STEP");
// Progress indicator
Handle(Draw_ProgressIndicator) progress = new Draw_ProgressIndicator ( di, 1 );
progress->SetScale ( 0, 100, 1 );
progress->Show();
STEPControl_Reader sr (XSDRAW::Session(),Standard_False);
TCollection_AsciiString fnom,rnom;
Standard_Boolean modfic = XSDRAW::FileAndVar
@ -102,6 +103,35 @@ static Standard_Integer stepread (Draw_Interpretor& di/*theCommands*/, Standard_
progress->NewScope ( 20, "Loading" ); // On average loading takes 20%
progress->Show();
Standard_Boolean fromtcl = Standard_False;
Standard_Boolean aFullMode = 0;
Standard_Integer k = 3;
if(argc > k )
{
if(argv[k][0] == 'f' || argv[3][0] == 'F')
{
aFullMode = Standard_True;
k++;
}
else if(argv[k][0] == 'r' || argv[3][0] == 'R')
{
aFullMode = Standard_False;
k++;
}
else
fromtcl = Standard_True;
}
if(!fromtcl)
fromtcl = argc > k;
if(aFullMode)
cout<<"Full model for translation with additional info will be used \n"<<flush;
else
cout<<"Reduced model for translation without additional info will be used \n"<<flush;
sr.WS()->SetModeStat(aFullMode);
if (modfic) readstat = sr.ReadFile (fnom.ToCString());
else if (XSDRAW::Session()->NbStartingEntities() > 0) readstat = IFSelect_RetDone;
@ -113,9 +143,9 @@ static Standard_Integer stepread (Draw_Interpretor& di/*theCommands*/, Standard_
else di<<"No model loaded"<<"\n";
return 1;
}
Standard_Boolean fromtcl = (argc > 3);
// nom = "." -> fichier deja lu
// nom = "." -> fichier deja lu
Standard_Integer i, num, nbs, modepri = 1;
if (fromtcl) modepri = 4;
Handle(Message_Messenger) aDIMessenger =
@ -125,9 +155,9 @@ static Standard_Integer stepread (Draw_Interpretor& di/*theCommands*/, Standard_
if (!fromtcl) {
di<<"NbRootsForTransfer="<<num<<" :\n";
for (i = 1; i <= num; i ++) {
di<<"Root."<<i<<", Ent. ";
sr.Model()->Print(sr.RootForTransfer(i),aDIMessenger);
di<<" Type:"<<sr.RootForTransfer(i)->DynamicType()->Name()<<"\n";
di<<"Root."<<i<<", Ent. ";
sr.Model()->Print(sr.RootForTransfer(i),aDIMessenger);
di<<" Type:"<<sr.RootForTransfer(i)->DynamicType()->Name()<<"\n";
}
cout<<"Mode (0 End, 1 root n0 1, 2 one root/n0, 3 one entity/n0, 4 Selection) : "<<flush;
@ -138,7 +168,7 @@ static Standard_Integer stepread (Draw_Interpretor& di/*theCommands*/, Standard_
if (modepri <= 2) {
num = 1;
if (modepri == 2) {
cout<<"Root N0 : "<<flush; cin>>num;
cout<<"Root N0 : "<<flush; cin>>num;
}
progress->NewScope ( 80, "Translation" );
@ -147,12 +177,12 @@ static Standard_Integer stepread (Draw_Interpretor& di/*theCommands*/, Standard_
if (!sr.TransferRoot (num)) di<<"Transfer root n0 "<<num<<" : no result"<<"\n";
else {
nbs = sr.NbShapes();
char shname[30]; sprintf (shname,"%s_%d",rnom.ToCString(),nbs);
di<<"Transfer root n0 "<<num<<" OK -> DRAW Shape: "<<shname<<"\n";
di<<"Now, "<<nbs<<" Shapes produced"<<"\n";
TopoDS_Shape sh = sr.Shape(nbs);
DBRep::Set (shname,sh);
nbs = sr.NbShapes();
char shname[30]; sprintf (shname,"%s_%d",rnom.ToCString(),nbs);
di<<"Transfer root n0 "<<num<<" OK -> DRAW Shape: "<<shname<<"\n";
di<<"Now, "<<nbs<<" Shapes produced"<<"\n";
TopoDS_Shape sh = sr.Shape(nbs);
DBRep::Set (shname,sh);
}
sr.WS()->MapReader()->SetProgress ( 0 );
@ -163,40 +193,40 @@ static Standard_Integer stepread (Draw_Interpretor& di/*theCommands*/, Standard_
cout<<"Entity : "<<flush; num = XSDRAW::GetEntityNumber();
if (!sr.TransferOne (num)) di<<"Transfer entity n0 "<<num<<" : no result"<<"\n";
else {
nbs = sr.NbShapes();
char shname[30]; sprintf (shname,"%s_%d",rnom.ToCString(),num);
di<<"Transfer entity n0 "<<num<<" OK -> DRAW Shape: "<<shname<<"\n";
di<<"Now, "<<nbs<<" Shapes produced"<<"\n";
TopoDS_Shape sh = sr.Shape(nbs);
DBRep::Set (shname,sh);
nbs = sr.NbShapes();
char shname[30]; sprintf (shname,"%s_%d",rnom.ToCString(),num);
di<<"Transfer entity n0 "<<num<<" OK -> DRAW Shape: "<<shname<<"\n";
di<<"Now, "<<nbs<<" Shapes produced"<<"\n";
TopoDS_Shape sh = sr.Shape(nbs);
DBRep::Set (shname,sh);
}
}
else if (modepri == 4) {
// char snm[100]; Standard_Integer answer = 1;
// char snm[100]; Standard_Integer answer = 1;
Handle(TColStd_HSequenceOfTransient) list;
// Selection, nommee ou via tcl. tcl : raccourcis admis
// * donne xst-transferrable-roots
// Selection, nommee ou via tcl. tcl : raccourcis admis
// * donne xst-transferrable-roots
if (fromtcl) {
modepri = 0; // d ioffice une seule passe
if (argv[3][0] == '*' && argv[3][1] == '\0') {
di<<"Transferrable Roots : ";
list = XSDRAW::GetList("xst-transferrable-roots");
modepri = 0; // d ioffice une seule passe
if (argv[k][0] == '*' && argv[k][1] == '\0') {
di<<"Transferrable Roots : ";
list = XSDRAW::GetList("xst-transferrable-roots");
//list = new TColStd_HSequenceOfTransient;
//for(Standard_Integer j=1; j<=num; j++)
// list->Append(sr.RootForTransfer(j));
}
}
else {
di<<"List given by "<<argv[3];
if (argc > 4) di<<" "<<argv[4];
di<<" : ";
list = XSDRAW::GetList (argv[3], ( argc > 4 ? argv[4] : 0 ) );
}
if (list.IsNull()) { di<<"No list defined. Give a selection name or * for all transferrable roots"<<"\n"; continue; }
di<<"List given by "<<argv[k];
if (argc > k+1) di<<" "<<argv[k+1];
di<<" : ";
list = XSDRAW::GetList (argv[k], ( argc > (k+1) ? argv[k+1] : 0 ) );
}
if (list.IsNull()) { di<<"No list defined. Give a selection name or * for all transferrable roots"<<"\n"; continue; }
} else {
cout<<"Name of Selection :"<<flush;
list = XSDRAW::GetList();
if (list.IsNull()) { di<<"No list defined"<<"\n"; continue; }
cout<<"Name of Selection :"<<flush;
list = XSDRAW::GetList();
if (list.IsNull()) { di<<"No list defined"<<"\n"; continue; }
}
Standard_Integer ill, nbl = list->Length();
@ -209,17 +239,17 @@ static Standard_Integer stepread (Draw_Interpretor& di/*theCommands*/, Standard_
Message_ProgressSentry PSentry ( progress, "Root", 0, nbl, 1 );
for (ill = 1; ill <= nbl && PSentry.More(); ill ++, PSentry.Next()) {
num = sr.Model()->Number(list->Value(ill));
if (num == 0) continue;
if (!sr.TransferOne(num)) di<<"Transfer entity n0 "<<num<<" : no result"<<"\n";
else {
nbs = sr.NbShapes();
char shname[30]; sprintf (shname,"%s_%d",rnom.ToCString(),nbs);
di<<"Transfer entity n0 "<<num<<" OK -> DRAW Shape: "<<shname<<"\n";
di<<"Now, "<<nbs<<" Shapes produced"<<"\n";
TopoDS_Shape sh = sr.Shape(nbs);
DBRep::Set (shname,sh);
}
num = sr.Model()->Number(list->Value(ill));
if (num == 0) continue;
if (!sr.TransferOne(num)) di<<"Transfer entity n0 "<<num<<" : no result"<<"\n";
else {
nbs = sr.NbShapes();
char shname[30]; sprintf (shname,"%s_%d",rnom.ToCString(),nbs);
di<<"Transfer entity n0 "<<num<<" OK -> DRAW Shape: "<<shname<<"\n";
di<<"Now, "<<nbs<<" Shapes produced"<<"\n";
TopoDS_Shape sh = sr.Shape(nbs);
DBRep::Set (shname,sh);
}
}
sr.WS()->MapReader()->SetProgress ( 0 );
progress->EndScope();
@ -512,7 +542,7 @@ void XSDRAWSTEP::InitCommands (Draw_Interpretor& theCommands)
XSDRAW::LoadDraw(theCommands);
theCommands.Add("stepwrite" , "stepwrite mode[0-4 afsmw] shape", __FILE__, stepwrite, g);
theCommands.Add("testwritestep", "testwritestep filename.stp shape", __FILE__, testwrite, g);
theCommands.Add("stepread", "stepread [file]", __FILE__, stepread, g);
theCommands.Add("stepread", "stepread [file] [f or r (type of model full or reduced)]",__FILE__, stepread, g);
theCommands.Add("testreadstep", "testreadstep [file] [name DRAW]", __FILE__, testread, g);
theCommands.Add("steptrans", "steptrans shape stepax1 stepax2", __FILE__, steptrans, g);
theCommands.Add("countexpected","TEST", __FILE__, countexpected, g);