lili/OCCT
1
0
Fork 0
mirror of https://github.com/Open-Cascade-SAS/OCCT.git synced 2026-08-01 11:34:54 +08:00
Code Issues Packages Projects Releases Wiki Activity
Files
714c81cd1d787b862d914c384c7d1223b9bebd5a
OCCT/src/IFSelect/IFSelect_ModelCopier.cxx
T
dpasukhi a5a7b3185b Coding - Apply .clang-format formatting #286 
Update empty method guards to new style with regex (see PR).
Used clang-format 18.1.8.
New actions to validate code formatting is added.
Update .clang-format with disabling of include sorting.
  It is temporary changes, then include will be sorted.
Apply formatting for /src and /tools folder.
The files with .hxx,.cxx,.lxx,.h,.pxx,.hpp,*.cpp extensions.
2025-01-26 00:43:57 +00:00

634 lines
22 KiB
C++
Raw Blame History

// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <IFSelect_AppliedModifiers.hxx>
#include <IFSelect_ContextModif.hxx>
#include <IFSelect_ContextWrite.hxx>
#include <IFSelect_GeneralModifier.hxx>
#include <IFSelect_ModelCopier.hxx>
#include <IFSelect_Modifier.hxx>
#include <IFSelect_Selection.hxx>
#include <IFSelect_ShareOut.hxx>
#include <IFSelect_ShareOutResult.hxx>
#include <IFSelect_WorkLibrary.hxx>
#include <Interface_Check.hxx>
#include <Interface_CheckIterator.hxx>
#include <Interface_CopyTool.hxx>
#include <Interface_EntityIterator.hxx>
#include <Interface_GeneralLib.hxx>
#include <Interface_Graph.hxx>
#include <Interface_InterfaceModel.hxx>
#include <Interface_Protocol.hxx>
#include <Message.hxx>
#include <Message_Messenger.hxx>
#include <Standard_Type.hxx>
#include <TCollection_AsciiString.hxx>
#include <TCollection_HAsciiString.hxx>
#include <stdio.h>
IMPLEMENT_STANDARD_RTTIEXT(IFSelect_ModelCopier, Standard_Transient)
// #define MISOPOINT
IFSelect_ModelCopier::IFSelect_ModelCopier() {}
void IFSelect_ModelCopier::SetShareOut(const Handle(IFSelect_ShareOut)& sho)
{
theshareout = sho;
}
// ########################################################################
// ######## OPERATIONS DE TRANSFERT GLOBAL (memorise ou non) ########
void IFSelect_ModelCopier::ClearResult()
{
thefilemodels.Clear();
thefilenames.Clear();
theapplieds.Clear();
theremain.Nullify();
}
Standard_Boolean IFSelect_ModelCopier::AddFile(const TCollection_AsciiString& filename,
const Handle(Interface_InterfaceModel)& content)
{
Standard_Integer nb = thefilenames.Length();
for (Standard_Integer i = 1; i <= nb; i++)
{
if (filename.IsEmpty())
continue;
if (thefilenames(i).IsEqual(filename))
return Standard_False;
}
Handle(IFSelect_AppliedModifiers) nulapplied;
thefilenames.Append(filename);
thefilemodels.Append(content);
theapplieds.Append(nulapplied);
return Standard_True;
}
Standard_Boolean IFSelect_ModelCopier::NameFile(const Standard_Integer num,
const TCollection_AsciiString& filename)
{
Standard_Integer nb = thefilenames.Length();
if (num <= 0 || num > nb)
return Standard_False;
for (Standard_Integer i = 1; i <= nb; i++)
{
if (filename.IsEmpty())
continue;
if (thefilenames(i).IsEqual(filename))
return Standard_False;
}
thefilenames.SetValue(num, filename);
return Standard_True;
}
Standard_Boolean IFSelect_ModelCopier::ClearFile(const Standard_Integer num)
{
Standard_Integer nb = thefilenames.Length();
if (num <= 0 || num > nb)
return Standard_False;
thefilenames.ChangeValue(num).Clear();
return Standard_True;
}
Standard_Boolean IFSelect_ModelCopier::SetAppliedModifiers(
const Standard_Integer num,
const Handle(IFSelect_AppliedModifiers)& applied)
{
Standard_Integer nb = theapplieds.Length();
if (num <= 0 || num > nb)
return Standard_False;
theapplieds.SetValue(num, applied);
return Standard_True;
}
Standard_Boolean IFSelect_ModelCopier::ClearAppliedModifiers(const Standard_Integer num)
{
Standard_Integer nb = theapplieds.Length();
if (num <= 0 || num > nb)
return Standard_False;
theapplieds.ChangeValue(num).Nullify();
return Standard_True;
}
// .... Copy : Opere les Transferts, les Memorise (pas d envoi fichier ici)
Interface_CheckIterator IFSelect_ModelCopier::Copy(IFSelect_ShareOutResult& eval,
const Handle(IFSelect_WorkLibrary)& WL,
const Handle(Interface_Protocol)& protocol)
{
Interface_CopyTool TC(eval.Graph().Model(), protocol);
return Copying(eval, WL, protocol, TC);
}
// Copy Interne
Interface_CheckIterator IFSelect_ModelCopier::Copying(IFSelect_ShareOutResult& eval,
const Handle(IFSelect_WorkLibrary)& WL,
const Handle(Interface_Protocol)& protocol,
Interface_CopyTool& TC)
{
Message::SendInfo() << "** WorkSession : Copying split data before sending" << std::endl;
const Interface_Graph& G = eval.Graph();
Interface_CheckIterator checks;
theshareout = eval.ShareOut();
theremain = new TColStd_HArray1OfInteger(0, G.Size());
theremain->Init(0);
for (eval.Evaluate(); eval.More(); eval.Next())
{
Handle(Interface_InterfaceModel) model;
TCollection_AsciiString filename = eval.FileName();
Standard_Integer dispnum = eval.DispatchRank();
Standard_Integer numod, nbmod;
eval.PacketsInDispatch(numod, nbmod);
Handle(IFSelect_AppliedModifiers) curapp;
CopiedModel(G,
WL,
protocol,
eval.PacketRoot(),
filename,
dispnum,
numod,
TC,
model,
curapp,
checks);
AddFile(filename, model);
theapplieds.SetValue(theapplieds.Length(), curapp);
}
theshareout->SetLastRun(theshareout->NbDispatches());
checks.SetName("X-STEP WorkSession : Split Copy (no Write)");
return checks;
}
// Send a deux arguments : Envoi Fichier du Resultat deja memorise
Interface_CheckIterator IFSelect_ModelCopier::SendCopied(const Handle(IFSelect_WorkLibrary)& WL,
const Handle(Interface_Protocol)& protocol)
{
Message::SendInfo() << "** WorkSession : Sending split data already copied" << std::endl;
Standard_Integer nb = NbFiles();
Interface_CheckIterator checks;
if (nb > 0)
{
for (Standard_Integer i = 1; i <= nb; i++)
{
if (FileName(i).Length() == 0)
continue;
Handle(IFSelect_AppliedModifiers) curapp = theapplieds.Value(i);
IFSelect_ContextWrite ctx(FileModel(i), protocol, curapp, FileName(i).ToCString());
Standard_Boolean res = WL->WriteFile(ctx);
Interface_CheckIterator checklst = ctx.CheckList();
checks.Merge(checklst);
// (FileName(i).ToCString(), FileModel(i),protocol,curapp,checks);
// if (!checks.IsEmpty(Standard_False)) {
// sout<<" ** On Sending File n0."<<i<<", Check Messages : **"<<std::endl;
// checks.Print (sout,Standard_False);
// }
if (!res)
{
char mess[100];
sprintf(mess, "Split Send (WriteFile) abandon on file n0.%d", i);
checks.CCheck(0)->AddFail(mess);
Message::SendInfo() << " ** Sending File n0." << i << " has failed, abandon **"
<< std::endl;
return checks;
}
AddSentFile(FileName(i).ToCString());
}
ClearResult();
}
checks.SetName("X-STEP WorkSession : Split Send (Copy+Write)");
return checks;
}
// .... Send a 4 arguments : Calcul du Transfert et Envoi sur Fichier
Interface_CheckIterator IFSelect_ModelCopier::Send(IFSelect_ShareOutResult& eval,
const Handle(IFSelect_WorkLibrary)& WL,
const Handle(Interface_Protocol)& protocol)
{
Interface_CopyTool TC(eval.Graph().Model(), protocol);
return Sending(eval, WL, protocol, TC);
}
Interface_CheckIterator IFSelect_ModelCopier::Sending(IFSelect_ShareOutResult& eval,
const Handle(IFSelect_WorkLibrary)& WL,
const Handle(Interface_Protocol)& protocol,
Interface_CopyTool& TC)
{
const Interface_Graph& G = eval.Graph();
Interface_CheckIterator checks;
Standard_Integer i = 0;
Message::SendInfo() << "** WorkSession : Copying then sending split data" << std::endl;
theshareout = eval.ShareOut();
theremain = new TColStd_HArray1OfInteger(0, G.Size());
theremain->Init(0);
for (eval.Evaluate(); eval.More(); eval.Next())
{
i++;
Handle(Interface_InterfaceModel) model;
TCollection_AsciiString filename = eval.FileName();
Standard_Integer dispnum = eval.DispatchRank();
Standard_Integer numod, nbmod;
eval.PacketsInDispatch(numod, nbmod);
Handle(IFSelect_AppliedModifiers) curapp;
CopiedModel(G,
WL,
protocol,
eval.PacketRoot(),
filename,
dispnum,
numod,
TC,
model,
curapp,
checks);
IFSelect_ContextWrite ctx(model, protocol, curapp, filename.ToCString());
Standard_Boolean res = WL->WriteFile(ctx);
Interface_CheckIterator checklst = ctx.CheckList();
checks.Merge(checklst);
// (filename.ToCString(), model, protocol, curapp, checks);
// if (!checks.IsEmpty(Standard_False)) {
// sout<<" ** On Sending File "<<filename<<", Check Messages : **"<<std::endl;
// checks.Print (sout,model,Standard_False);
// }
if (!res)
{
char mess[100];
sprintf(mess, "Split Send (WriteFile) abandon on file n0.%d", i);
checks.CCheck(0)->AddFail(mess);
Message::SendInfo() << " ** Sending File " << filename << " has failed, abandon **"
<< std::endl;
checks.SetName("X-STEP WorkSession : Split Send (only Write)");
return checks;
}
AddSentFile(filename.ToCString());
}
theshareout->SetLastRun(theshareout->NbDispatches());
checks.SetName("X-STEP WorkSession : Split Send (only Write)");
return checks;
}
// .... SendAll : Donnees a tranferer dans G, aucun split, envoi sur fichier
Interface_CheckIterator IFSelect_ModelCopier::SendAll(const Standard_CString filename,
const Interface_Graph& G,
const Handle(IFSelect_WorkLibrary)& WL,
const Handle(Interface_Protocol)& protocol)
{
Interface_CheckIterator checks;
checks.SetName("X-STEP WorkSession : Send All");
Message::SendInfo() << "** WorkSession : Sending all data" << std::endl;
const Handle(Interface_InterfaceModel)& model = G.Model();
if (model.IsNull() || protocol.IsNull() || WL.IsNull())
return checks;
Interface_CopyTool TC(model, protocol);
Standard_Integer i, nb = model->NbEntities();
for (i = 1; i <= nb; i++)
TC.Bind(model->Value(i), model->Value(i));
Interface_EntityIterator pipo;
Handle(Interface_InterfaceModel) newmod;
Handle(IFSelect_AppliedModifiers) applied;
CopiedModel(G,
WL,
protocol,
pipo,
TCollection_AsciiString(filename),
0,
0,
TC,
newmod,
applied,
checks);
IFSelect_ContextWrite ctx(model, protocol, applied, filename);
Standard_Boolean res = WL->WriteFile(ctx);
Interface_CheckIterator checklst = ctx.CheckList();
checks.Merge(checklst);
if (!res)
checks.CCheck(0)->AddFail("SendAll (WriteFile) has failed");
// if (!checks.IsEmpty(Standard_False)) {
// Message::SendWarning() <<
// " ** SendAll has produced Check Messages : **"<<std::endl;
// checks.Print (sout,model,Standard_False);
// }
return checks;
}
// .... SendSelected : Donnees a tranferer dans G, filtrees par iter,
// aucun split, envoi sur fichier
Interface_CheckIterator IFSelect_ModelCopier::SendSelected(
const Standard_CString filename,
const Interface_Graph& G,
const Handle(IFSelect_WorkLibrary)& WL,
const Handle(Interface_Protocol)& protocol,
const Interface_EntityIterator& list)
{
Interface_CheckIterator checks;
checks.SetName("X-STEP WorkSession : Send Selected");
Message::SendInfo() << "** WorkSession : Sending selected data" << std::endl;
const Handle(Interface_InterfaceModel)& original = G.Model();
if (original.IsNull() || protocol.IsNull() || WL.IsNull())
return checks;
Handle(Interface_InterfaceModel) newmod = original->NewEmptyModel();
Interface_CopyTool TC(original, protocol);
TC.FillModel(newmod); // pour Header ...
// Pas de copie : AddWithRefs plus declaration de Bind
Interface_GeneralLib lib(protocol);
for (list.Start(); list.More(); list.Next())
{
newmod->AddWithRefs(list.Value(), lib);
}
Standard_Integer i, nb = newmod->NbEntities();
for (i = 1; i <= nb; i++)
TC.Bind(newmod->Value(i), newmod->Value(i));
if (theremain.IsNull())
{
theremain = new TColStd_HArray1OfInteger(0, G.Size());
theremain->Init(0);
}
Interface_EntityIterator pipo;
Handle(IFSelect_AppliedModifiers) applied;
CopiedModel(G,
WL,
protocol,
pipo,
TCollection_AsciiString(filename),
0,
0,
TC,
newmod,
applied,
checks);
// Alimenter Remaining : les entites copiees sont a noter
Handle(Standard_Transient) ent1, ent2;
for (Standard_Integer ic = TC.LastCopiedAfter(0, ent1, ent2); ic > 0;
ic = TC.LastCopiedAfter(ic, ent1, ent2))
{
if (ic <= theremain->Upper())
theremain->SetValue(ic, theremain->Value(ic) + 1);
}
IFSelect_ContextWrite ctx(newmod, protocol, applied, filename);
Standard_Boolean res = WL->WriteFile(ctx);
Interface_CheckIterator checklst = ctx.CheckList();
checks.Merge(checklst);
if (!res)
checks.CCheck(0)->AddFail("SendSelected (WriteFile) has failed");
// if (!checks.IsEmpty(Standard_False)) {
// Message::SendWarning() <<
// " ** SendSelected has produced Check Messages : **"<<std::endl;
// checks.Print (sout,original,Standard_False);
// }
return checks;
}
// ##########################################################################
// ######## UN TRANSFERT UNITAIRE (avec Modifications) ########
void IFSelect_ModelCopier::CopiedModel(const Interface_Graph& G,
const Handle(IFSelect_WorkLibrary)& WL,
const Handle(Interface_Protocol)& protocol,
const Interface_EntityIterator& tocopy,
const TCollection_AsciiString& filename,
const Standard_Integer dispnum,
const Standard_Integer /* numod */,
Interface_CopyTool& TC,
Handle(Interface_InterfaceModel)& newmod,
Handle(IFSelect_AppliedModifiers)& applied,
Interface_CheckIterator& checks) const
{
// ... Premiere partie "standard" : remplissage du modele ...
// On cree le Modele, on le remplit avec les Entites, et avec le Header depart
// ATTENTION : dispnum = 0 signifie prendre modele original, ne rien copier
// et aussi : pas de Dispatch (envoi en bloc)
applied.Nullify();
const Handle(Interface_InterfaceModel)& original = G.Model();
if (dispnum > 0)
{
newmod = original->NewEmptyModel();
TC.Clear();
WL->CopyModel(original, newmod, tocopy, TC);
Handle(Standard_Transient) ent1, ent2;
// Alimenter Remaining : les entites copiees sont a noter
for (Standard_Integer ic = TC.LastCopiedAfter(0, ent1, ent2); ic > 0;
ic = TC.LastCopiedAfter(ic, ent1, ent2))
{
if (ic <= theremain->Upper())
theremain->SetValue(ic, theremain->Value(ic) + 1);
}
}
else if (newmod.IsNull())
newmod = original;
// ... Ensuite : On prend en compte les Model Modifiers ...
Standard_Integer nbmod = 0;
if (!theshareout.IsNull())
nbmod = theshareout->NbModifiers(Standard_True);
Standard_Integer i; // svv Jan11 2000 : porting on DEC
for (i = 1; i <= nbmod; i++)
{
Handle(IFSelect_Modifier) unmod = theshareout->ModelModifier(i);
// D abord, critere Dispatch/Packet
if (dispnum > 0)
if (!unmod->Applies(theshareout->Dispatch(dispnum)))
continue;
IFSelect_ContextModif ctx(G, TC, filename.ToCString());
// Ensuite, la Selection
Handle(IFSelect_Selection) sel = unmod->Selection();
if (!sel.IsNull())
{
Interface_EntityIterator entiter = sel->UniqueResult(G);
ctx.Select(entiter);
}
if (ctx.IsForNone())
continue;
unmod->Perform(ctx, newmod, protocol, TC);
Interface_CheckIterator checklst = ctx.CheckList();
checks.Merge(checklst);
// Faut-il enregistrer les erreurs dans newmod ? bonne question
// if (!checks.IsEmpty(Standard_False)) {
// Message::SendWarning() <<
// " Messages on Copied Model n0 "<<numod<<", Dispatch Rank "<<dispnum<<std::endl;
// checks.Print(sout,newmod,Standard_False);
// }
}
// ... Puis les File Modifiers : en fait, on les enregistre ...
nbmod = 0;
if (!theshareout.IsNull())
nbmod = theshareout->NbModifiers(Standard_False);
if (nbmod == 0)
return;
applied = new IFSelect_AppliedModifiers(nbmod, newmod->NbEntities());
for (i = 1; i <= nbmod; i++)
{
Handle(IFSelect_GeneralModifier) unmod = theshareout->GeneralModifier(Standard_False, i);
// D abord, critere Dispatch/Packet
if (dispnum > 0)
if (!unmod->Applies(theshareout->Dispatch(dispnum)))
continue;
// Ensuite, la Selection
Handle(IFSelect_Selection) sel = unmod->Selection();
if (sel.IsNull())
applied->AddModif(unmod); // vide -> on prend tout
else
{
Interface_EntityIterator list = sel->UniqueResult(G);
Handle(Standard_Transient) newent;
// Entites designees par la Selection et Copiees ?
// -> s ilyena au moins une, le Modifier s applique, sinon il est rejete
// -> et cette liste est exploitable par le Modifier ...
for (list.Start(); list.More(); list.Next())
{
if (TC.Search(list.Value(), newent))
applied->AddNum(newmod->Number(newent));
}
}
}
}
void IFSelect_ModelCopier::CopiedRemaining(const Interface_Graph& G,
const Handle(IFSelect_WorkLibrary)& WL,
Interface_CopyTool& TC,
Handle(Interface_InterfaceModel)& newmod)
{
const Handle(Interface_InterfaceModel)& original = G.Model();
// Interface_CopyTool TC(original,protocol);
newmod = original->NewEmptyModel();
TC.Clear();
Interface_EntityIterator tocopy;
Standard_Integer nb = G.Size();
theremain = new TColStd_HArray1OfInteger(0, nb + 1);
theremain->Init(0);
for (Standard_Integer i = 1; i <= nb; i++)
{
if (G.Status(i) == 0)
tocopy.AddItem(original->Value(i));
else
theremain->SetValue(i, -1); // ?? -1
}
WL->CopyModel(original, newmod, tocopy, TC);
if (newmod->NbEntities() == 0)
newmod.Nullify();
else
{
// CE QUI SUIT NE DOIT PAS ETRE SUPPRIME ! cf theremain
Handle(Standard_Transient) ent1, ent2;
for (Standard_Integer ic = TC.LastCopiedAfter(0, ent1, ent2); ic > 0;
ic = TC.LastCopiedAfter(ic, ent1, ent2))
{
if (ic <= theremain->Upper())
theremain->SetValue(ic, 1);
}
// qq impressions de mise au point
#ifdef MISOPOINT
std::cout << " Remaining Model : " << newmod->NbEntities() << " Entities" << std::endl;
Standard_Integer ne = 0;
for (i = 1; i <= nb; i++)
{
if (theremain->Value(i) == 0)
{
if (ne == 0)
std::cout << " Refractaires : ";
ne++;
std::cout << " " << i;
}
}
if (ne > 0)
std::cout << " -- " << ne << " Entities" << std::endl;
else
std::cout << " -- Remaining data complete" << std::endl;
#endif
}
}
Standard_Boolean IFSelect_ModelCopier::SetRemaining(Interface_Graph& CG) const
{
Standard_Integer nb = CG.Size();
if (theremain.IsNull())
return (nb == 0);
if (nb != theremain->Upper())
return Standard_False;
for (Standard_Integer i = 1; i <= nb; i++)
{
if (CG.Status(i) >= 0)
CG.SetStatus(i, CG.Status(i) + theremain->Value(i));
}
theremain->Init(0);
return Standard_True;
}
// ##########################################################################
// ######## RESULTAT de la Memorisation des Transferts ########
Standard_Integer IFSelect_ModelCopier::NbFiles() const
{
return thefilemodels.Length();
}
TCollection_AsciiString IFSelect_ModelCopier::FileName(const Standard_Integer num) const
{
return thefilenames.Value(num);
}
Handle(Interface_InterfaceModel) IFSelect_ModelCopier::FileModel(const Standard_Integer num) const
{
return thefilemodels.Value(num);
}
Handle(IFSelect_AppliedModifiers) IFSelect_ModelCopier::AppliedModifiers(
const Standard_Integer num) const
{
return theapplieds.Value(num);
}
void IFSelect_ModelCopier::BeginSentFiles(const Handle(IFSelect_ShareOut)& sho,
const Standard_Boolean record)
{
thesentfiles.Nullify();
if (record)
thesentfiles = new TColStd_HSequenceOfHAsciiString();
// et numerotation des fichiers par defaut : detenue par ShareOut
if (sho.IsNull())
return;
Standard_Integer lastrun = sho->LastRun();
sho->ClearResult(Standard_True);
sho->SetLastRun(lastrun); // on ne s interesse quaux numeros
}
void IFSelect_ModelCopier::AddSentFile(const Standard_CString filename)
{
if (!thesentfiles.IsNull())
thesentfiles->Append(new TCollection_HAsciiString(filename));
}
Handle(TColStd_HSequenceOfHAsciiString) IFSelect_ModelCopier::SentFiles() const
{
return thesentfiles;
}
Reference in New Issue View Git Blame Copy Permalink