(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)
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);
thecopier : ModelCopier; -- produces + memorizes transferred data
theoldel : InterfaceModel;
-
+ themodelstat : Boolean;
end WorkSession;
thecopier->SetShareOut (theshareout);
thecheckdone = Standard_False;
thegtool = new Interface_GTool;
+ themodelstat = Standard_False;
}
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
//function :
//purpose :
//=======================================================================
-
Handle(Interface_InterfaceModel) IFSelect_WorkSession::Model () const
{
return themodel;
}
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;
}
{
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;
}
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;
}
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);
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;
}
}
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;
}
// 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
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;
// 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);
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 ...
}
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);
}
}
sout<<"\n Abandon"<<endl;
}
}
+
+void IFSelect_WorkSession::SetModeStat( Standard_Boolean theStatMode)
+{
+ themodelstat = theStatMode;
+}
+
+Standard_Boolean IFSelect_WorkSession::GetModeStat() const
+{
+ return themodelstat;
+}
Standard_Integer IGESGeom_BoundedSurface::NbBoundaries () const
{
- return theBoundaries->Length();
+
+ return ( theBoundaries.IsNull() ? 0 : theBoundaries->Length());
}
Handle(IGESGeom_Boundary) IGESGeom_BoundedSurface::Boundary
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;
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
#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)
+{
+ Initialize(nbitems,resflags);
+}
- Interface_BitMap::Interface_BitMap
- (const Standard_Integer nbitems, const Standard_Integer 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)
+{
+
+ Initialize(other,copied);
}
- Interface_BitMap::Interface_BitMap
- (const Interface_BitMap& other, const Standard_Boolean copied)
+void Interface_BitMap::Initialize(const Interface_BitMap& other,
+ const Standard_Boolean copied)
{
other.Internals (thenbitems,thenbwords,thenbflags,theflags,thenames);
if (!copied) return;
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 ...
}
- 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;
}
- Standard_Integer Interface_BitMap::AddFlag (const Standard_CString name)
+Standard_Integer Interface_BitMap::AddFlag (const Standard_CString name)
{
Reservate(1);
Standard_Integer deja = 0;
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));
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();
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());
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) );
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;
// 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);
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);
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;
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;
}
- 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);
+}
\ No newline at end of file
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
//purpose :
//=======================================================================
-void Interface_FileReaderTool::Destroy(){}
+void Interface_FileReaderTool::Destroy()
+{}
+void Interface_FileReaderTool::Clear()
+{
+ theproto.Nullify();
+ thereader.Nullify();
+ themodel.Nullify();
+ thereports.Nullify();
+}
\ No newline at end of file
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;
}
-- 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
-- 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
---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
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
-- 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
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;
#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
// .... 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())
-{
- Handle(Interface_GTool) gtool; // null
- theflags.AddFlag ("ShareError"); // -> flag n0 1
- Evaluate(lib,gtool);
-}
-
- 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 Interface_GeneralLib& lib,
+ Standard_Boolean theModeStat)
+ : themodel (amodel), thepresents ("")
{
- Handle(Interface_GTool) gtool; // null
- theflags.AddFlag ("ShareError"); // -> flag n0 1
- Evaluate(Interface_GeneralLib(protocol),gtool);
-}
-
- 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())
+ if(theModeStat)
+ InitStats();
+ Evaluate();
+}
+
+Interface_Graph::Interface_Graph
+(const Handle(Interface_InterfaceModel)& amodel,
+ const Handle(Interface_Protocol)& protocol,
+ 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,
+ const Handle(Interface_GTool)& gtool,
+ 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)
+Interface_Graph::Interface_Graph
+(const Handle(Interface_InterfaceModel)& amodel,
+ Standard_Boolean theModeStat)
+: themodel (amodel) , thepresents ("")
{
-// Evaluation d un Graphe de dependances : sur chaque Entite, on prend sa
-// liste "Shared". On en deduit les "Sharing" directement
+ if(theModeStat)
+ InitStats();
+ Evaluate ();
+}
- 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);
+// .... Construction depuis un autre Graph ....
-// 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();
+Interface_Graph::Interface_Graph
+(const Interface_Graph& agraph, const Standard_Boolean /*copied*/)
+: themodel (agraph.Model()), thepresents ("")
+{
+ 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));
+ theflags.Initialize(agraph.BitMap(),Standard_True);
+}
-// Resultat obtenu via GeneralLib
- Interface_EntityIterator iter;
- Handle(Interface_GeneralModule) module;
- Standard_Integer CN;
+void Interface_Graph::InitStats()
+{
+ thestats = new TColStd_HArray1OfInteger(1,themodel->NbEntities()) ,
+ theflags.Initialize(themodel->NbEntities(),2);
+ theflags.AddFlag ("ShareError");
+}
- 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);
- }
+Standard_Integer Interface_Graph::NbStatuses() const
+{
+ return (thestats.IsNull() ? 0 : thestats->Length());
+}
- 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
- }
- }
- }
+const Handle(TColStd_HArray1OfListOfInteger)& Interface_Graph::SharingTable () const
+{ return thesharings; }
-// Les references inverses : preallocation (pour compte > 1 seulement)
+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;
+
- 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
+ Standard_Integer i; // svv Jan11 2000 : porting on DEC
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);
- }
- }
+ // 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);
- 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);
+ // 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 ....
- 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)
-{
- Standard_Integer nb = Size();
- for (Standard_Integer i = 1; i <= nb; i ++)
- thestats.SetValue (i,agraph.Status(i));
-}
-
- Interface_IntList Interface_Graph::BasicSharedTable () const
- { return theshareds; }
-
- Interface_IntList Interface_Graph::RedefinedSharedTable () const
- { return thesharnews; }
-
- Interface_IntList Interface_Graph::SharingTable () const
- { return thesharings; }
-
// ###########################################################################
// .... 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); }
+void Interface_Graph::ResetStatus ()
+{
+ if(!thestats.IsNull())
+ {
+ thestats->Init(0);
+ theflags.Init (Standard_False, Graph_Present);
+ }
+}
- Standard_Integer Interface_Graph::Size () const
- { return thestats.Upper(); }
+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_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_Boolean Interface_Graph::IsPresent
+(const Standard_Integer num) const
{
- if (num <= 0 || num > Size()) return Standard_False;
- return theflags.Value (num,Graph_Present);
+ 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_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); }
+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)
- { thestats.SetValue(num,stat); }
+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)
+void Interface_Graph::RemoveItem(const Standard_Integer num)
{
- thestats.SetValue(num,0); theflags.SetFalse (num,Graph_Present);
+ if(!thestats.IsNull())
+ {
+ thestats->SetValue(num,0);
+ theflags.SetFalse (num,Graph_Present);
+ }
}
- void Interface_Graph::ChangeStatus
- (const Standard_Integer oldstat, const Standard_Integer newstat)
+void Interface_Graph::ChangeStatus
+(const Standard_Integer oldstat, const Standard_Integer newstat)
{
- Standard_Integer nb = thestats.Upper();
+ 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);
+ if (thestats->Value(i) == oldstat)
+ thestats->SetValue(i,newstat);
}
}
- void Interface_Graph::RemoveStatus(const Standard_Integer stat)
+void Interface_Graph::RemoveStatus(const Standard_Integer stat)
{
- Standard_Integer nb = thestats.Upper();
+ if(thestats.IsNull())
+ return;
+ Standard_Integer nb = thestats->Upper();
for (Standard_Integer i = 1; i <= nb; i ++) {
- if (thestats.Value(i) == stat) RemoveItem(i);
+ if (thestats->Value(i) == stat) RemoveItem(i);
}
}
- const Interface_BitMap& Interface_Graph::BitMap () const
- { return theflags; }
-
- Interface_BitMap& Interface_Graph::CBitMap ()
- { return theflags; }
+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");
}
}
- 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");
// .... 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
{
+ Interface_EntityIterator iter;
Standard_Integer num = EntityNumber(ent);
- if (num == 0) return Standard_False;
- return thesharnews.IsRedefined (num);
-}
+ if(!num)
+ return iter;
- Interface_EntityIterator Interface_Graph::Shareds
- (const Handle(Standard_Transient)& ent) const
-{
- Standard_Integer num = EntityNumber(ent);
- if (num == 0) Standard_DomainError::Raise ("Interface : Shareds");
+ Handle(Standard_Transient) aCurEnt = ent;
+ if (themodel->IsRedefinedContent(num))
+ aCurEnt = themodel->ReportEntity(num)->Content();
- 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) ));
+ //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");
+ 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_EntityIterator Interface_Graph::Sharings
+(const Handle(Standard_Transient)& ent) const
+{
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)));
+ iter.AddList(GetSharings(ent));
return iter;
-}
- Interface_IntList Interface_Graph::SharingNums
- (const Standard_Integer num) const
-{
- Interface_IntList list = thesharings;
- if (num > 0) list.SetNumber (num);
- return list;
}
-
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;
Interface_ShareTool sht (*this);
return module->Name (CN,ent,sht);
}
+
+Standard_Boolean Interface_Graph::ModeStat() const
+{
+ return (!thestats.IsNull());
+}
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);
}
}
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
#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
}
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
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
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();
}
}
if (yena) thegraph.EvalSharings();
-}
+}*/
Handle(Interface_InterfaceModel) Interface_ShareTool::Model () const
(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
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 ++;
}
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;
uses Type, HAsciiString from TCollection,
Messenger from Message,
- DataMapOfTransientInteger,
+ HArray1OfInteger from TColStd,
EntityList, EntityIterator, Check
raises NoSuchObject
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
fields
theheader : EntityList;
- theidnums : DataMapOfTransientInteger;
+ theidnums : HArray1OfInteger from TColStd;
end StepModel;
// 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;
}
}
- 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
}
- 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();
}
- 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
-{
- if (theidnums.IsBound(ent)) return theidnums.Find(ent);
- return 0;
}
- void StepData_StepModel::PrintLabel
- (const Handle(Standard_Transient)& ent, const Handle(Message_Messenger)& S) const
+Standard_Integer StepData_StepModel::IdentLabel
+(const Handle(Standard_Transient)& ent) const
{
- Standard_Integer num = 0 , nid = 0;
- if (theidnums.IsBound(ent)) nid = theidnums.Find(ent);
- if (nid <= 0) num = Number(ent);
-
+ 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
+{
+ 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);
readtool.PrepareHeader(recoheader); // Header. reco nul -> pour Protocol
readtool.Prepare(recodata); // Data. reco nul -> pour Protocol
+
#ifdef CHRONOMESURE
sout << " ... Parameters prepared ... ";
c.Show();
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 ;
}
thegraph = HG;
if (!thegraph.IsNull())
SetModel(thegraph->Graph().Model());
+ else
+ themodel.Nullify();
}
#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
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);
}
theTransfer.Nullify();
theActor.Nullify();
theFilename.Clear();
- } // theContext.Nullify();
+ }
}
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);
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);
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);
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);
- // }
+
}
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) ***
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();
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;
}
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());
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
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;
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 =
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;
if (modepri <= 2) {
num = 1;
if (modepri == 2) {
- cout<<"Root N0 : "<<flush; cin>>num;
+ cout<<"Root N0 : "<<flush; cin>>num;
}
progress->NewScope ( 80, "Translation" );
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 );
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();
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();
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);