ASSERT(SINGLETON_<SALOME_NamingService>::IsAlreadyExisting());
_NS->init_orb(_orb);
+ CORBA::Object_var aStudyObject = _NS->Resolve( "/Study" );
+ myStudy = SALOMEDS::Study::_narrow( aStudyObject );
+
_tag_gene = 0 ;
_tag_boun = 0 ;
_tag_hypo = 0 ;
// Utilitaires pour l'étude
//=============================================================================
//=============================================================================
-void HOMARD_Gen_i::addInStudy(SALOMEDS::Study_ptr theStudy)
+void HOMARD_Gen_i::UpdateStudy()
{
- ASSERT(!CORBA::is_nil(theStudy));
- MESSAGE("addInStudy: ajout eventuel du composant HOMARD dans current study ID = " << GetCurrentStudyID()) ;
- SALOMEDS::StudyBuilder_var myBuilder = theStudy->NewBuilder();
+ ASSERT(!CORBA::is_nil(myStudy));
+ SALOMEDS::StudyBuilder_var myBuilder = myStudy->NewBuilder();
// Create SComponent labelled 'homard' if it doesn't already exit
- SALOMEDS::SComponent_var homardFather = theStudy->FindComponent(ComponentDataType());
+ SALOMEDS::SComponent_var homardFather = myStudy->FindComponent(ComponentDataType());
if (CORBA::is_nil(homardFather))
{
myBuilder->NewCommand();
MESSAGE("Add Component HOMARD");
- bool aLocked = theStudy->GetProperties()->IsLocked();
- if (aLocked) theStudy->GetProperties()->SetLocked(false);
+ bool aLocked = myStudy->GetProperties()->IsLocked();
+ if (aLocked) myStudy->GetProperties()->SetLocked(false);
homardFather = myBuilder->NewComponent(ComponentDataType());
SALOMEDS::GenericAttribute_var anAttr = myBuilder->FindOrCreateAttribute(homardFather,"AttributeName");
aPixmap->SetPixMap("HOMARD_2.png");
myBuilder->DefineComponentInstance(homardFather, HOMARD_Gen::_this());
- if (aLocked) theStudy->GetProperties()->SetLocked(true);
+ if (aLocked) myStudy->GetProperties()->SetLocked(true);
myBuilder->CommitCommand();
}
}
-//=============================================================================
-void HOMARD_Gen_i::SetCurrentStudy(SALOMEDS::Study_ptr theStudy)
-{
- MESSAGE("SetCurrentStudy: current study Id = " << GetCurrentStudyID());
- myCurrentStudy = SALOMEDS::Study::_duplicate(theStudy);
- this->addInStudy(myCurrentStudy);
-}
-//=============================================================================
-SALOMEDS::Study_ptr HOMARD_Gen_i::GetCurrentStudy()
-//=============================================================================
-{
- MESSAGE("GetCurrentStudy: study Id = " << GetCurrentStudyID());
- return SALOMEDS::Study::_duplicate(myCurrentStudy);
-}
-//=============================================================================
-CORBA::Long HOMARD_Gen_i::GetCurrentStudyID()
-//=============================================================================
-{
- return myCurrentStudy->_is_nil() ? -1 : myCurrentStudy->StudyId();
-}
-//=============================================================================
-//=============================================================================
//=============================================================================
//=============================================================================
//=====================================================================================
{
MESSAGE( "SetEtatIter : affectation de l'etat " << Etat << " a l'iteration " << nomIter );
- HOMARD::HOMARD_Iteration_var myIteration = myContextMap[GetCurrentStudyID()]._mesIterations[nomIter];
+ HOMARD::HOMARD_Iteration_var myIteration = myStudyContext._mesIterations[nomIter];
if (CORBA::is_nil(myIteration))
{
SALOME::ExceptionStruct es;
myIteration->SetState(Etat);
- SALOMEDS::StudyBuilder_var aStudyBuilder = myCurrentStudy->NewBuilder();
- SALOMEDS::SObject_var aIterSO = SALOMEDS::SObject::_narrow(myCurrentStudy->FindObjectIOR(_orb->object_to_string(myIteration)));
+ SALOMEDS::StudyBuilder_var aStudyBuilder = myStudy->NewBuilder();
+ SALOMEDS::SObject_var aIterSO = SALOMEDS::SObject::_narrow(myStudy->FindObjectIOR(_orb->object_to_string(myIteration)));
std::string icone ;
if ( Etat <= 0 )
CORBA::Long HOMARD_Gen_i::DeleteBoundary(const char* BoundaryName)
{
MESSAGE ( "DeleteBoundary : BoundaryName = " << BoundaryName );
- HOMARD::HOMARD_Boundary_var myBoundary = myContextMap[GetCurrentStudyID()]._mesBoundarys[BoundaryName];
+ HOMARD::HOMARD_Boundary_var myBoundary = myStudyContext._mesBoundarys[BoundaryName];
if (CORBA::is_nil(myBoundary))
{
SALOME::ExceptionStruct es;
{
CaseName = std::string((*maListe)[NumeCas]);
MESSAGE ( "... Examen du cas = " << CaseName.c_str() );
- myCase = myContextMap[GetCurrentStudyID()]._mesCas[CaseName];
+ myCase = myStudyContext._mesCas[CaseName];
ASSERT(!CORBA::is_nil(myCase));
ListBoundaryGroupType = myCase->GetBoundaryGroup();
numberOfitems = ListBoundaryGroupType->length();
}
// comme on a un _var comme pointeur CORBA, on ne se preoccupe pas du delete
- myContextMap[GetCurrentStudyID()]._mesBoundarys.erase(BoundaryName);
- SALOMEDS::Study::ListOfSObject_var listSO = myCurrentStudy->FindObjectByName(BoundaryName, ComponentDataType());
+ myStudyContext._mesBoundarys.erase(BoundaryName);
+ SALOMEDS::Study::ListOfSObject_var listSO = myStudy->FindObjectByName(BoundaryName, ComponentDataType());
SALOMEDS::SObject_var aSO =listSO[0];
- SALOMEDS::StudyBuilder_var aStudyBuilder = myCurrentStudy->NewBuilder();
- myCurrentStudy->NewBuilder()->RemoveObjectWithChildren(aSO);
+ SALOMEDS::StudyBuilder_var aStudyBuilder = myStudy->NewBuilder();
+ myStudy->NewBuilder()->RemoveObjectWithChildren(aSO);
return 0 ;
}
{
// Pour detruire un cas
MESSAGE ( "DeleteCase : nomCas = " << nomCas << ", avec option = " << Option );
- HOMARD::HOMARD_Cas_var myCase = myContextMap[GetCurrentStudyID()]._mesCas[nomCas];
+ HOMARD::HOMARD_Cas_var myCase = myStudyContext._mesCas[nomCas];
if (CORBA::is_nil(myCase))
{
SALOME::ExceptionStruct es;
};
// comme on a un _var comme pointeur CORBA, on ne se preoccupe pas du delete
- myContextMap[GetCurrentStudyID()]._mesCas.erase(nomCas);
- SALOMEDS::Study::ListOfSObject_var listSO = myCurrentStudy->FindObjectByName(nomCas, ComponentDataType());
+ myStudyContext._mesCas.erase(nomCas);
+ SALOMEDS::Study::ListOfSObject_var listSO = myStudy->FindObjectByName(nomCas, ComponentDataType());
SALOMEDS::SObject_var aSO =listSO[0];
- SALOMEDS::StudyBuilder_var aStudyBuilder = myCurrentStudy->NewBuilder();
- myCurrentStudy->NewBuilder()->RemoveObjectWithChildren(aSO);
+ SALOMEDS::StudyBuilder_var aStudyBuilder = myStudy->NewBuilder();
+ myStudy->NewBuilder()->RemoveObjectWithChildren(aSO);
return 0 ;
}
CORBA::Long HOMARD_Gen_i::DeleteHypo(const char* nomHypo)
{
MESSAGE ( "DeleteHypo : nomHypo = " << nomHypo );
- HOMARD::HOMARD_Hypothesis_var myHypo = myContextMap[GetCurrentStudyID()]._mesHypotheses[nomHypo];
+ HOMARD::HOMARD_Hypothesis_var myHypo = myStudyContext._mesHypotheses[nomHypo];
if (CORBA::is_nil(myHypo))
{
SALOME::ExceptionStruct es;
}
// comme on a un _var comme pointeur CORBA, on ne se preoccupe pas du delete
- myContextMap[GetCurrentStudyID()]._mesHypotheses.erase(nomHypo);
- SALOMEDS::Study::ListOfSObject_var listSO = myCurrentStudy->FindObjectByName(nomHypo, ComponentDataType());
+ myStudyContext._mesHypotheses.erase(nomHypo);
+ SALOMEDS::Study::ListOfSObject_var listSO = myStudy->FindObjectByName(nomHypo, ComponentDataType());
SALOMEDS::SObject_var aSO =listSO[0];
- SALOMEDS::StudyBuilder_var aStudyBuilder = myCurrentStudy->NewBuilder();
- myCurrentStudy->NewBuilder()->RemoveObjectWithChildren(aSO);
+ SALOMEDS::StudyBuilder_var aStudyBuilder = myStudy->NewBuilder();
+ myStudy->NewBuilder()->RemoveObjectWithChildren(aSO);
return 0 ;
}
// Option2 = 0 : On ne supprime pas le fichier du maillage associe
// Option2 = 1 : On supprime le fichier du maillage associe
MESSAGE ( "DeleteIterationOption : nomIter = " << nomIter << ", avec options = " << Option1<< ", " << Option2 );
- HOMARD::HOMARD_Iteration_var myIteration = myContextMap[GetCurrentStudyID()]._mesIterations[nomIter];
+ HOMARD::HOMARD_Iteration_var myIteration = myStudyContext._mesIterations[nomIter];
if (CORBA::is_nil(myIteration))
{
SALOME::ExceptionStruct es;
{
std::string nomIterationParent = myIteration->GetIterParentName();
MESSAGE ( "Retrait dans la descendance de nomIterationParent " << nomIterationParent );
- HOMARD::HOMARD_Iteration_var myIterationParent = myContextMap[GetCurrentStudyID()]._mesIterations[nomIterationParent];
+ HOMARD::HOMARD_Iteration_var myIterationParent = myStudyContext._mesIterations[nomIterationParent];
if (CORBA::is_nil(myIterationParent))
{
SALOME::ExceptionStruct es;
if ( numero > 0 )
{
std::string nomHypo = myIteration->GetHypoName();
- HOMARD::HOMARD_Hypothesis_var myHypo = myContextMap[GetCurrentStudyID()]._mesHypotheses[nomHypo];
+ HOMARD::HOMARD_Hypothesis_var myHypo = myStudyContext._mesHypotheses[nomHypo];
ASSERT(!CORBA::is_nil(myHypo));
myHypo->UnLinkIteration(nomIter);
}
// comme on a un _var comme pointeur CORBA, on ne se preoccupe pas du delete
- myContextMap[GetCurrentStudyID()]._mesIterations.erase(nomIter);
- SALOMEDS::Study::ListOfSObject_var listSO = myCurrentStudy->FindObjectByName(nomIter, ComponentDataType());
+ myStudyContext._mesIterations.erase(nomIter);
+ SALOMEDS::Study::ListOfSObject_var listSO = myStudy->FindObjectByName(nomIter, ComponentDataType());
SALOMEDS::SObject_var aSO =listSO[0];
- SALOMEDS::StudyBuilder_var aStudyBuilder = myCurrentStudy->NewBuilder();
- myCurrentStudy->NewBuilder()->RemoveObjectWithChildren(aSO);
+ SALOMEDS::StudyBuilder_var aStudyBuilder = myStudy->NewBuilder();
+ myStudy->NewBuilder()->RemoveObjectWithChildren(aSO);
// on peut aussi faire RemoveObject
// MESSAGE ( "Au final" );
// HOMARD::listeIterations* Liste = GetAllIterationsName() ;
// Option = 0 : On ne supprime pas le fichier du schema associe
// Option = 1 : On supprime le fichier du schema associe
MESSAGE ( "DeleteYACS : nomYACS = " << nomYACS << ", avec option = " << Option );
- HOMARD::HOMARD_YACS_var myYACS = myContextMap[GetCurrentStudyID()]._mesYACSs[nomYACS];
+ HOMARD::HOMARD_YACS_var myYACS = myStudyContext._mesYACSs[nomYACS];
if (CORBA::is_nil(myYACS))
{
SALOME::ExceptionStruct es;
}
}
// comme on a un _var comme pointeur CORBA, on ne se preoccupe pas du delete
- myContextMap[GetCurrentStudyID()]._mesYACSs.erase(nomYACS);
- SALOMEDS::Study::ListOfSObject_var listSO = myCurrentStudy->FindObjectByName(nomYACS, ComponentDataType());
+ myStudyContext._mesYACSs.erase(nomYACS);
+ SALOMEDS::Study::ListOfSObject_var listSO = myStudy->FindObjectByName(nomYACS, ComponentDataType());
SALOMEDS::SObject_var aSO =listSO[0];
- SALOMEDS::StudyBuilder_var aStudyBuilder = myCurrentStudy->NewBuilder();
- myCurrentStudy->NewBuilder()->RemoveObjectWithChildren(aSO);
+ SALOMEDS::StudyBuilder_var aStudyBuilder = myStudy->NewBuilder();
+ myStudy->NewBuilder()->RemoveObjectWithChildren(aSO);
return 0 ;
}
CORBA::Long HOMARD_Gen_i::DeleteZone(const char* nomZone)
{
MESSAGE ( "DeleteZone : nomZone = " << nomZone );
- HOMARD::HOMARD_Zone_var myZone = myContextMap[GetCurrentStudyID()]._mesZones[nomZone];
+ HOMARD::HOMARD_Zone_var myZone = myStudyContext._mesZones[nomZone];
if (CORBA::is_nil(myZone))
{
SALOME::ExceptionStruct es;
};
//
// comme on a un _var comme pointeur CORBA, on ne se preoccupe pas du delete
- myContextMap[GetCurrentStudyID()]._mesZones.erase(nomZone);
- SALOMEDS::Study::ListOfSObject_var listSO = myCurrentStudy->FindObjectByName(nomZone, ComponentDataType());
+ myStudyContext._mesZones.erase(nomZone);
+ SALOMEDS::Study::ListOfSObject_var listSO = myStudy->FindObjectByName(nomZone, ComponentDataType());
SALOMEDS::SObject_var aSO =listSO[0];
- SALOMEDS::StudyBuilder_var aStudyBuilder = myCurrentStudy->NewBuilder();
- myCurrentStudy->NewBuilder()->RemoveObjectWithChildren(aSO);
+ SALOMEDS::StudyBuilder_var aStudyBuilder = myStudy->NewBuilder();
+ myStudy->NewBuilder()->RemoveObjectWithChildren(aSO);
return 0 ;
}
void HOMARD_Gen_i::InvalideBoundary(const char* BoundaryName)
{
MESSAGE( "InvalideBoundary : BoundaryName = " << BoundaryName );
- HOMARD::HOMARD_Boundary_var myBoundary = myContextMap[GetCurrentStudyID()]._mesBoundarys[BoundaryName];
+ HOMARD::HOMARD_Boundary_var myBoundary = myStudyContext._mesBoundarys[BoundaryName];
if (CORBA::is_nil(myBoundary))
{
SALOME::ExceptionStruct es;
void HOMARD_Gen_i::InvalideHypo(const char* nomHypo)
{
MESSAGE( "InvalideHypo : nomHypo = " << nomHypo );
- HOMARD::HOMARD_Hypothesis_var myHypo = myContextMap[GetCurrentStudyID()]._mesHypotheses[nomHypo];
+ HOMARD::HOMARD_Hypothesis_var myHypo = myStudyContext._mesHypotheses[nomHypo];
if (CORBA::is_nil(myHypo))
{
SALOME::ExceptionStruct es;
// Option = 0 : On ne supprime pas le fichier du maillage associe
// Option = 1 : On supprime le fichier du maillage associe
MESSAGE ( "InvalideIterOption : nomIter = " << nomIter << ", avec option = " << Option );
- HOMARD::HOMARD_Iteration_var myIteration = myContextMap[GetCurrentStudyID()]._mesIterations[nomIter];
+ HOMARD::HOMARD_Iteration_var myIteration = myStudyContext._mesIterations[nomIter];
if (CORBA::is_nil(myIteration))
{
SALOME::ExceptionStruct es;
// On arrive ici pour une iteration sans fille
MESSAGE ( "Invalidation effective de " << nomIter );
- SALOMEDS::SObject_var aIterSO = SALOMEDS::SObject::_narrow(myCurrentStudy->FindObjectIOR(_orb->object_to_string(myIteration)));
- SALOMEDS::ChildIterator_var aIter = myCurrentStudy->NewChildIterator(aIterSO);
+ SALOMEDS::SObject_var aIterSO = SALOMEDS::SObject::_narrow(myStudy->FindObjectIOR(_orb->object_to_string(myIteration)));
+ SALOMEDS::ChildIterator_var aIter = myStudy->NewChildIterator(aIterSO);
for (; aIter->More(); aIter->Next())
{
SALOMEDS::SObject_var so = aIter->Value();
std::string value (aCommentAttr->Value());
if(value == std::string("IterationHomard")) continue;
if(value == std::string("HypoHomard")) continue;
- SALOMEDS::StudyBuilder_var aStudyBuilder = myCurrentStudy->NewBuilder();
+ SALOMEDS::StudyBuilder_var aStudyBuilder = myStudy->NewBuilder();
aStudyBuilder->RemoveObject(so);
}
{
SetEtatIter(nomIter,1);
const char * nomCas = myIteration->GetCaseName();
- HOMARD::HOMARD_Cas_var myCase = myContextMap[GetCurrentStudyID()]._mesCas[nomCas];
+ HOMARD::HOMARD_Cas_var myCase = myStudyContext._mesCas[nomCas];
if (CORBA::is_nil(myCase))
{
SALOME::ExceptionStruct es;
void HOMARD_Gen_i::InvalideIterInfo(const char* nomIter)
{
MESSAGE("InvalideIterInfo : nomIter = " << nomIter);
- HOMARD::HOMARD_Iteration_var myIteration = myContextMap[GetCurrentStudyID()]._mesIterations[nomIter];
+ HOMARD::HOMARD_Iteration_var myIteration = myStudyContext._mesIterations[nomIter];
if (CORBA::is_nil(myIteration))
{
SALOME::ExceptionStruct es;
return ;
};
- SALOMEDS::SObject_var aIterSO = SALOMEDS::SObject::_narrow(myCurrentStudy->FindObjectIOR(_orb->object_to_string(myIteration)));
- SALOMEDS::ChildIterator_var aIter = myCurrentStudy->NewChildIterator(aIterSO);
+ SALOMEDS::SObject_var aIterSO = SALOMEDS::SObject::_narrow(myStudy->FindObjectIOR(_orb->object_to_string(myIteration)));
+ SALOMEDS::ChildIterator_var aIter = myStudy->NewChildIterator(aIterSO);
for (; aIter->More(); aIter->Next())
{
SALOMEDS::SObject_var so = aIter->Value();
/* MESSAGE("... value = " << value);*/
if( (value == std::string("logInfo")) || ( value == std::string("SummaryInfo")) )
{
- SALOMEDS::StudyBuilder_var aStudyBuilder = myCurrentStudy->NewBuilder();
+ SALOMEDS::StudyBuilder_var aStudyBuilder = myStudy->NewBuilder();
aStudyBuilder->RemoveObject(so);
}
}
const char * nomCas = myIteration->GetCaseName();
- HOMARD::HOMARD_Cas_var myCase = myContextMap[GetCurrentStudyID()]._mesCas[nomCas];
+ HOMARD::HOMARD_Cas_var myCase = myStudyContext._mesCas[nomCas];
if (CORBA::is_nil(myCase))
{
SALOME::ExceptionStruct es;
void HOMARD_Gen_i::InvalideYACS(const char* YACSName)
{
MESSAGE( "InvalideYACS : YACSName = " << YACSName );
- HOMARD::HOMARD_YACS_var myYACS = myContextMap[GetCurrentStudyID()]._mesYACSs[YACSName];
+ HOMARD::HOMARD_YACS_var myYACS = myStudyContext._mesYACSs[YACSName];
if (CORBA::is_nil(myYACS))
{
SALOME::ExceptionStruct es;
return ;
};
//
- SALOMEDS::SObject_var aYACSSO = SALOMEDS::SObject::_narrow(myCurrentStudy->FindObjectIOR(_orb->object_to_string(myYACS)));
- SALOMEDS::ChildIterator_var aYACS = myCurrentStudy->NewChildIterator(aYACSSO);
+ SALOMEDS::SObject_var aYACSSO = SALOMEDS::SObject::_narrow(myStudy->FindObjectIOR(_orb->object_to_string(myYACS)));
+ SALOMEDS::ChildIterator_var aYACS = myStudy->NewChildIterator(aYACSSO);
for (; aYACS->More(); aYACS->Next())
{
SALOMEDS::SObject_var so = aYACS->Value();
std::string value (aCommentAttr->Value());
if( value == std::string("xml") )
{
- SALOMEDS::StudyBuilder_var aStudyBuilder = myCurrentStudy->NewBuilder();
+ SALOMEDS::StudyBuilder_var aStudyBuilder = myStudy->NewBuilder();
aStudyBuilder->RemoveObject(so);
}
}
void HOMARD_Gen_i::InvalideZone(const char* ZoneName)
{
MESSAGE( "InvalideZone : ZoneName = " << ZoneName );
- HOMARD::HOMARD_Zone_var myZone = myContextMap[GetCurrentStudyID()]._mesZones[ZoneName];
+ HOMARD::HOMARD_Zone_var myZone = myStudyContext._mesZones[ZoneName];
if (CORBA::is_nil(myZone))
{
SALOME::ExceptionStruct es;
{
MESSAGE( "AssociateCaseIter : " << nomCas << ", " << nomIter << ", " << labelIter );
- HOMARD::HOMARD_Cas_var myCase = myContextMap[GetCurrentStudyID()]._mesCas[nomCas];
+ HOMARD::HOMARD_Cas_var myCase = myStudyContext._mesCas[nomCas];
if (CORBA::is_nil(myCase))
{
SALOME::ExceptionStruct es;
return ;
};
- HOMARD::HOMARD_Iteration_var myIteration = myContextMap[GetCurrentStudyID()]._mesIterations[nomIter];
+ HOMARD::HOMARD_Iteration_var myIteration = myStudyContext._mesIterations[nomIter];
if (CORBA::is_nil(myIteration))
{
SALOME::ExceptionStruct es;
return ;
};
- SALOMEDS::StudyBuilder_var aStudyBuilder = myCurrentStudy->NewBuilder();
- SALOMEDS::SObject_var aCasSO = SALOMEDS::SObject::_narrow(myCurrentStudy->FindObjectIOR(_orb->object_to_string(myCase)));
+ SALOMEDS::StudyBuilder_var aStudyBuilder = myStudy->NewBuilder();
+ SALOMEDS::SObject_var aCasSO = SALOMEDS::SObject::_narrow(myStudy->FindObjectIOR(_orb->object_to_string(myCase)));
if (CORBA::is_nil(aCasSO))
{
SALOME::ExceptionStruct es;
{
MESSAGE ( "AssociateHypoZone : nomHypo = " << nomHypothesis << ", ZoneName= " << ZoneName << ", TypeUse = " << TypeUse);
- HOMARD::HOMARD_Hypothesis_var myHypo = myContextMap[GetCurrentStudyID()]._mesHypotheses[nomHypothesis];
+ HOMARD::HOMARD_Hypothesis_var myHypo = myStudyContext._mesHypotheses[nomHypothesis];
ASSERT(!CORBA::is_nil(myHypo));
- SALOMEDS::SObject_var aHypoSO = SALOMEDS::SObject::_narrow(myCurrentStudy->FindObjectIOR(_orb->object_to_string(myHypo)));
+ SALOMEDS::SObject_var aHypoSO = SALOMEDS::SObject::_narrow(myStudy->FindObjectIOR(_orb->object_to_string(myHypo)));
ASSERT(!CORBA::is_nil(aHypoSO));
- HOMARD::HOMARD_Zone_var myZone = myContextMap[GetCurrentStudyID()]._mesZones[ZoneName];
+ HOMARD::HOMARD_Zone_var myZone = myStudyContext._mesZones[ZoneName];
ASSERT(!CORBA::is_nil(myZone));
- SALOMEDS::SObject_var aZoneSO = SALOMEDS::SObject::_narrow(myCurrentStudy->FindObjectIOR(_orb->object_to_string(myZone)));
+ SALOMEDS::SObject_var aZoneSO = SALOMEDS::SObject::_narrow(myStudy->FindObjectIOR(_orb->object_to_string(myZone)));
ASSERT(!CORBA::is_nil(aZoneSO));
- SALOMEDS::StudyBuilder_var aStudyBuilder = myCurrentStudy->NewBuilder();
+ SALOMEDS::StudyBuilder_var aStudyBuilder = myStudy->NewBuilder();
aStudyBuilder->NewCommand();
MESSAGE("AssociateIterHypo : nomHypo = " << nomHypo << " nomIter = " << nomIter);
// Verification de l'existence de l'hypothese
- HOMARD::HOMARD_Hypothesis_var myHypo = myContextMap[GetCurrentStudyID()]._mesHypotheses[nomHypo];
+ HOMARD::HOMARD_Hypothesis_var myHypo = myStudyContext._mesHypotheses[nomHypo];
ASSERT(!CORBA::is_nil(myHypo));
- SALOMEDS::SObject_var aHypoSO = SALOMEDS::SObject::_narrow(myCurrentStudy->FindObjectIOR(_orb->object_to_string(myHypo)));
+ SALOMEDS::SObject_var aHypoSO = SALOMEDS::SObject::_narrow(myStudy->FindObjectIOR(_orb->object_to_string(myHypo)));
ASSERT(!CORBA::is_nil(aHypoSO));
// Verification de l'existence de l'iteration
- HOMARD::HOMARD_Iteration_var myIteration = myContextMap[GetCurrentStudyID()]._mesIterations[nomIter];
+ HOMARD::HOMARD_Iteration_var myIteration = myStudyContext._mesIterations[nomIter];
ASSERT(!CORBA::is_nil(myIteration));
- SALOMEDS::SObject_var aIterSO = SALOMEDS::SObject::_narrow(myCurrentStudy->FindObjectIOR(_orb->object_to_string(myIteration)));
+ SALOMEDS::SObject_var aIterSO = SALOMEDS::SObject::_narrow(myStudy->FindObjectIOR(_orb->object_to_string(myIteration)));
ASSERT(!CORBA::is_nil(aIterSO));
// Gestion de l'arbre d'etudes
- SALOMEDS::StudyBuilder_var aStudyBuilder = myCurrentStudy->NewBuilder();
+ SALOMEDS::StudyBuilder_var aStudyBuilder = myStudy->NewBuilder();
aStudyBuilder->NewCommand();
SALOMEDS::SObject_var aSubSO = aStudyBuilder->NewObject(aIterSO);
aStudyBuilder->Addreference(aSubSO, aHypoSO);
{
MESSAGE ( "DissociateHypoZone : ZoneName= " << ZoneName << ", nomHypo = " << nomHypothesis);
- HOMARD::HOMARD_Hypothesis_var myHypo = myContextMap[GetCurrentStudyID()]._mesHypotheses[nomHypothesis];
+ HOMARD::HOMARD_Hypothesis_var myHypo = myStudyContext._mesHypotheses[nomHypothesis];
ASSERT(!CORBA::is_nil(myHypo));
- SALOMEDS::SObject_var aHypoSO = SALOMEDS::SObject::_narrow(myCurrentStudy->FindObjectIOR(_orb->object_to_string(myHypo)));
+ SALOMEDS::SObject_var aHypoSO = SALOMEDS::SObject::_narrow(myStudy->FindObjectIOR(_orb->object_to_string(myHypo)));
ASSERT(!CORBA::is_nil(aHypoSO));
- HOMARD::HOMARD_Zone_var myZone = myContextMap[GetCurrentStudyID()]._mesZones[ZoneName];
+ HOMARD::HOMARD_Zone_var myZone = myStudyContext._mesZones[ZoneName];
ASSERT(!CORBA::is_nil(myZone));
- SALOMEDS::SObject_var aZoneSO = SALOMEDS::SObject::_narrow(myCurrentStudy->FindObjectIOR(_orb->object_to_string(myZone)));
+ SALOMEDS::SObject_var aZoneSO = SALOMEDS::SObject::_narrow(myStudy->FindObjectIOR(_orb->object_to_string(myZone)));
ASSERT(!CORBA::is_nil(aZoneSO));
- SALOMEDS::StudyBuilder_var aStudyBuilder = myCurrentStudy->NewBuilder();
+ SALOMEDS::StudyBuilder_var aStudyBuilder = myStudy->NewBuilder();
- SALOMEDS::ChildIterator_var it = myCurrentStudy->NewChildIterator(aHypoSO);
+ SALOMEDS::ChildIterator_var it = myStudy->NewChildIterator(aHypoSO);
for (; it->More(); it->Next())
{
SALOMEDS::SObject_var aHypObj = it->Value();
IsValidStudy () ;
HOMARD::listeBoundarys_var ret = new HOMARD::listeBoundarys;
- ret->length(myContextMap[GetCurrentStudyID()]._mesBoundarys.size());
+ ret->length(myStudyContext._mesBoundarys.size());
std::map<std::string, HOMARD::HOMARD_Boundary_var>::const_iterator it;
int i = 0;
- for (it = myContextMap[GetCurrentStudyID()]._mesBoundarys.begin();
- it != myContextMap[GetCurrentStudyID()]._mesBoundarys.end(); it++)
+ for (it = myStudyContext._mesBoundarys.begin();
+ it != myStudyContext._mesBoundarys.end(); it++)
{
ret[i++] = CORBA::string_dup((*it).first.c_str());
}
IsValidStudy () ;
HOMARD::listeCases_var ret = new HOMARD::listeCases;
- ret->length(myContextMap[GetCurrentStudyID()]._mesCas.size());
+ ret->length(myStudyContext._mesCas.size());
std::map<std::string, HOMARD::HOMARD_Cas_var>::const_iterator it;
int i = 0;
- for (it = myContextMap[GetCurrentStudyID()]._mesCas.begin();
- it != myContextMap[GetCurrentStudyID()]._mesCas.end(); it++)
+ for (it = myStudyContext._mesCas.begin();
+ it != myStudyContext._mesCas.end(); it++)
{
ret[i++] = CORBA::string_dup((*it).first.c_str());
}
IsValidStudy () ;
HOMARD::listeHypotheses_var ret = new HOMARD::listeHypotheses;
- ret->length(myContextMap[GetCurrentStudyID()]._mesHypotheses.size());
+ ret->length(myStudyContext._mesHypotheses.size());
std::map<std::string, HOMARD::HOMARD_Hypothesis_var>::const_iterator it;
int i = 0;
- for (it = myContextMap[GetCurrentStudyID()]._mesHypotheses.begin();
- it != myContextMap[GetCurrentStudyID()]._mesHypotheses.end(); it++)
+ for (it = myStudyContext._mesHypotheses.begin();
+ it != myStudyContext._mesHypotheses.end(); it++)
{
ret[i++] = CORBA::string_dup((*it).first.c_str());
}
IsValidStudy () ;
HOMARD::listeIterations_var ret = new HOMARD::listeIterations;
- ret->length(myContextMap[GetCurrentStudyID()]._mesIterations.size());
+ ret->length(myStudyContext._mesIterations.size());
std::map<std::string, HOMARD::HOMARD_Iteration_var>::const_iterator it;
int i = 0;
- for (it = myContextMap[GetCurrentStudyID()]._mesIterations.begin();
- it != myContextMap[GetCurrentStudyID()]._mesIterations.end(); it++)
+ for (it = myStudyContext._mesIterations.begin();
+ it != myStudyContext._mesIterations.end(); it++)
{
ret[i++] = CORBA::string_dup((*it).first.c_str());
}
IsValidStudy () ;
HOMARD::listeYACSs_var ret = new HOMARD::listeYACSs;
- ret->length(myContextMap[GetCurrentStudyID()]._mesYACSs.size());
+ ret->length(myStudyContext._mesYACSs.size());
std::map<std::string, HOMARD::HOMARD_YACS_var>::const_iterator it;
int i = 0;
- for (it = myContextMap[GetCurrentStudyID()]._mesYACSs.begin();
- it != myContextMap[GetCurrentStudyID()]._mesYACSs.end(); it++)
+ for (it = myStudyContext._mesYACSs.begin();
+ it != myStudyContext._mesYACSs.end(); it++)
{
ret[i++] = CORBA::string_dup((*it).first.c_str());
}
IsValidStudy () ;
HOMARD::listeZones_var ret = new HOMARD::listeZones;
- ret->length(myContextMap[GetCurrentStudyID()]._mesZones.size());
+ ret->length(myStudyContext._mesZones.size());
std::map<std::string, HOMARD::HOMARD_Zone_var>::const_iterator it;
int i = 0;
- for (it = myContextMap[GetCurrentStudyID()]._mesZones.begin();
- it != myContextMap[GetCurrentStudyID()]._mesZones.end(); it++)
+ for (it = myStudyContext._mesZones.begin();
+ it != myStudyContext._mesZones.end(); it++)
{
ret[i++] = CORBA::string_dup((*it).first.c_str());
}
//=============================================================================
HOMARD::HOMARD_Boundary_ptr HOMARD_Gen_i::GetBoundary(const char* nomBoundary)
{
- HOMARD::HOMARD_Boundary_var myBoundary = myContextMap[GetCurrentStudyID()]._mesBoundarys[nomBoundary];
+ HOMARD::HOMARD_Boundary_var myBoundary = myStudyContext._mesBoundarys[nomBoundary];
ASSERT(!CORBA::is_nil(myBoundary));
return HOMARD::HOMARD_Boundary::_duplicate(myBoundary);
}
//=============================================================================
HOMARD::HOMARD_Cas_ptr HOMARD_Gen_i::GetCase(const char* nomCas)
{
- HOMARD::HOMARD_Cas_var myCase = myContextMap[GetCurrentStudyID()]._mesCas[nomCas];
+ HOMARD::HOMARD_Cas_var myCase = myStudyContext._mesCas[nomCas];
ASSERT(!CORBA::is_nil(myCase));
return HOMARD::HOMARD_Cas::_duplicate(myCase);
}
//=============================================================================
HOMARD::HOMARD_Hypothesis_ptr HOMARD_Gen_i::GetHypothesis(const char* nomHypothesis)
{
- HOMARD::HOMARD_Hypothesis_var myHypothesis = myContextMap[GetCurrentStudyID()]._mesHypotheses[nomHypothesis];
+ HOMARD::HOMARD_Hypothesis_var myHypothesis = myStudyContext._mesHypotheses[nomHypothesis];
ASSERT(!CORBA::is_nil(myHypothesis));
return HOMARD::HOMARD_Hypothesis::_duplicate(myHypothesis);
}
//=============================================================================
HOMARD::HOMARD_Iteration_ptr HOMARD_Gen_i::GetIteration(const char* NomIterationation)
{
- HOMARD::HOMARD_Iteration_var myIteration = myContextMap[GetCurrentStudyID()]._mesIterations[NomIterationation];
+ HOMARD::HOMARD_Iteration_var myIteration = myStudyContext._mesIterations[NomIterationation];
ASSERT(!CORBA::is_nil(myIteration));
return HOMARD::HOMARD_Iteration::_duplicate(myIteration);
}
//=============================================================================
HOMARD::HOMARD_YACS_ptr HOMARD_Gen_i::GetYACS(const char* nomYACS)
{
- HOMARD::HOMARD_YACS_var myYACS = myContextMap[GetCurrentStudyID()]._mesYACSs[nomYACS];
+ HOMARD::HOMARD_YACS_var myYACS = myStudyContext._mesYACSs[nomYACS];
ASSERT(!CORBA::is_nil(myYACS));
return HOMARD::HOMARD_YACS::_duplicate(myYACS);
}
//=============================================================================
HOMARD::HOMARD_Zone_ptr HOMARD_Gen_i::GetZone(const char* ZoneName)
{
- HOMARD::HOMARD_Zone_var myZone = myContextMap[GetCurrentStudyID()]._mesZones[ZoneName];
+ HOMARD::HOMARD_Zone_var myZone = myStudyContext._mesZones[ZoneName];
ASSERT(!CORBA::is_nil(myZone));
return HOMARD::HOMARD_Zone::_duplicate(myZone);
}
//=============================================================================
HOMARD::HOMARD_Iteration_ptr HOMARD_Gen_i::LastIteration(const char* nomCas)
{
- HOMARD::HOMARD_Cas_var myCase = myContextMap[GetCurrentStudyID()]._mesCas[nomCas];
+ HOMARD::HOMARD_Cas_var myCase = myStudyContext._mesCas[nomCas];
ASSERT(!CORBA::is_nil(myCase));
//
HOMARD::HOMARD_Iteration_var myIteration = myCase->LastIteration();
IsValidStudy () ;
// A.2. Controle du nom :
- if ((myContextMap[GetCurrentStudyID()]._mesCas).find(nomCas)!=(myContextMap[GetCurrentStudyID()]._mesCas).end())
+ if ((myStudyContext._mesCas).find(nomCas)!=(myStudyContext._mesCas).end())
{
SALOME::ExceptionStruct es;
es.type = SALOME::BAD_PARAM;
HOMARD::HOMARD_Cas_var myCase = newCase();
myCase->SetName(nomCas);
SALOMEDS::SObject_var aSO;
- SALOMEDS::SObject_var aResultSO=PublishInStudy(myCurrentStudy, aSO, myCase, nomCas);
- myContextMap[GetCurrentStudyID()]._mesCas[nomCas] = myCase;
+ SALOMEDS::SObject_var aResultSO=PublishInStudy(aSO, myCase, nomCas);
+ myStudyContext._mesCas[nomCas] = myCase;
// C. Caracteristiques du maillage
if ( existeMeshFile != 0 )
// Si ce nom d'iteration existe deja, on incremente avec 0, 1, 2, etc.
int monNum = 0;
std::string NomIteration = std::string(MeshName) ;
- while ( (myContextMap[GetCurrentStudyID()]._mesIterations).find(NomIteration) != (myContextMap[GetCurrentStudyID()]._mesIterations.end()) )
+ while ( (myStudyContext._mesIterations).find(NomIteration) != (myStudyContext._mesIterations.end()) )
{
std::ostringstream nom;
nom << MeshName << monNum;
// D.2. Creation de l'iteration
HOMARD::HOMARD_Iteration_var anIter = newIteration();
- myContextMap[GetCurrentStudyID()]._mesIterations[NomIteration] = anIter;
+ myStudyContext._mesIterations[NomIteration] = anIter;
anIter->SetName(NomIteration.c_str());
AssociateCaseIter (nomCas, NomIteration.c_str(), "IterationHomard");
IsValidStudy () ;
// A. Controle du nom :
- if ((myContextMap[GetCurrentStudyID()]._mesHypotheses).find(nomHypothesis) != (myContextMap[GetCurrentStudyID()]._mesHypotheses).end())
+ if ((myStudyContext._mesHypotheses).find(nomHypothesis) != (myStudyContext._mesHypotheses).end())
{
SALOME::ExceptionStruct es;
es.type = SALOME::BAD_PARAM;
myHypothesis->SetName(nomHypothesis);
// C. Enregistrement
- myContextMap[GetCurrentStudyID()]._mesHypotheses[nomHypothesis] = myHypothesis;
+ myStudyContext._mesHypotheses[nomHypothesis] = myHypothesis;
SALOMEDS::SObject_var aSO;
- SALOMEDS::SObject_var aResultSO=PublishInStudy(myCurrentStudy, aSO, myHypothesis, nomHypothesis);
+ SALOMEDS::SObject_var aResultSO=PublishInStudy(aSO, myHypothesis, nomHypothesis);
// D. Valeurs par defaut des options avancees
myHypothesis->SetNivMax(-1);
INFOS ("CreateIteration : NomIteration = " << NomIteration << ", nomIterParent = " << nomIterParent);
IsValidStudy () ;
- HOMARD::HOMARD_Iteration_var myIterationParent = myContextMap[GetCurrentStudyID()]._mesIterations[nomIterParent];
+ HOMARD::HOMARD_Iteration_var myIterationParent = myStudyContext._mesIterations[nomIterParent];
if (CORBA::is_nil(myIterationParent))
{
SALOME::ExceptionStruct es;
const char* nomCas = myIterationParent->GetCaseName();
MESSAGE ("CreateIteration : nomCas = " << nomCas);
- HOMARD::HOMARD_Cas_var myCase = myContextMap[GetCurrentStudyID()]._mesCas[nomCas];
+ HOMARD::HOMARD_Cas_var myCase = myStudyContext._mesCas[nomCas];
if (CORBA::is_nil(myCase))
{
SALOME::ExceptionStruct es;
const char* nomDirCase = myCase->GetDirName();
// Controle du nom :
- if ((myContextMap[GetCurrentStudyID()]._mesIterations).find(NomIteration)!=(myContextMap[GetCurrentStudyID()]._mesIterations).end())
+ if ((myStudyContext._mesIterations).find(NomIteration)!=(myStudyContext._mesIterations).end())
{
SALOME::ExceptionStruct es;
es.type = SALOME::BAD_PARAM;
throw SALOME::SALOME_Exception(es);
return 0;
};
- myContextMap[GetCurrentStudyID()]._mesIterations[std::string(NomIteration)] = myIteration;
+ myStudyContext._mesIterations[std::string(NomIteration)] = myIteration;
// Nom de l'iteration et du maillage
myIteration->SetName(NomIteration);
myIteration->SetMeshName(NomIteration);
myIterationParent->LinkNextIteration(NomIteration);
myIteration->SetIterParentName(nomIterParent);
// Gestion de l'arbre d'etudes
- SALOMEDS::SObject_var aIterSOParent = SALOMEDS::SObject::_narrow(myCurrentStudy->FindObjectIOR(_orb->object_to_string(myIterationParent)));
- SALOMEDS::SObject_var aIterSO = SALOMEDS::SObject::_narrow(myCurrentStudy->FindObjectIOR(_orb->object_to_string(myIteration)));
- SALOMEDS::StudyBuilder_var aStudyBuilder = myCurrentStudy->NewBuilder();
+ SALOMEDS::SObject_var aIterSOParent = SALOMEDS::SObject::_narrow(myStudy->FindObjectIOR(_orb->object_to_string(myIterationParent)));
+ SALOMEDS::SObject_var aIterSO = SALOMEDS::SObject::_narrow(myStudy->FindObjectIOR(_orb->object_to_string(myIteration)));
+ SALOMEDS::StudyBuilder_var aStudyBuilder = myStudy->NewBuilder();
aStudyBuilder->NewCommand();
SALOMEDS::SObject_var aSubSO = aStudyBuilder->NewObject(aIterSO);
aStudyBuilder->Addreference(aSubSO, aIterSOParent);
IsValidStudy () ;
// Controle du nom :
- if ((myContextMap[GetCurrentStudyID()]._mesBoundarys).find(BoundaryName)!=(myContextMap[GetCurrentStudyID()]._mesBoundarys).end())
+ if ((myStudyContext._mesBoundarys).find(BoundaryName)!=(myStudyContext._mesBoundarys).end())
{
MESSAGE ("CreateBoundary : la frontiere " << BoundaryName << " existe deja");
SALOME::ExceptionStruct es;
myBoundary->SetName(BoundaryName);
myBoundary->SetType(BoundaryType);
- myContextMap[GetCurrentStudyID()]._mesBoundarys[BoundaryName] = myBoundary;
+ myStudyContext._mesBoundarys[BoundaryName] = myBoundary;
SALOMEDS::SObject_var aSO;
- SALOMEDS::SObject_var aResultSO=PublishInStudy(myCurrentStudy, aSO, myBoundary, BoundaryName);
+ SALOMEDS::SObject_var aResultSO=PublishInStudy(aSO, myBoundary, BoundaryName);
return HOMARD::HOMARD_Boundary::_duplicate(myBoundary);
}
IsValidStudy () ;
// Controle du nom :
- if ((myContextMap[GetCurrentStudyID()]._mesZones).find(ZoneName)!=(myContextMap[GetCurrentStudyID()]._mesZones).end())
+ if ((myStudyContext._mesZones).find(ZoneName)!=(myStudyContext._mesZones).end())
{
SALOME::ExceptionStruct es;
es.type = SALOME::BAD_PARAM;
myZone->SetName(ZoneName);
myZone->SetType(ZoneType);
- myContextMap[GetCurrentStudyID()]._mesZones[ZoneName] = myZone;
+ myStudyContext._mesZones[ZoneName] = myZone;
SALOMEDS::SObject_var aSO;
- SALOMEDS::SObject_var aResultSO=PublishInStudy(myCurrentStudy, aSO, myZone, ZoneName);
+ SALOMEDS::SObject_var aResultSO=PublishInStudy(aSO, myZone, ZoneName);
return HOMARD::HOMARD_Zone::_duplicate(myZone);
}
int codret = 0;
// A.1. L'objet iteration
- HOMARD::HOMARD_Iteration_var myIteration = myContextMap[GetCurrentStudyID()]._mesIterations[NomIteration];
+ HOMARD::HOMARD_Iteration_var myIteration = myStudyContext._mesIterations[NomIteration];
ASSERT(!CORBA::is_nil(myIteration));
// A.2. Controle de la possibilite d'agir
// A.4. Le cas
const char* nomCas = myIteration->GetCaseName();
- HOMARD::HOMARD_Cas_var myCase = myContextMap[GetCurrentStudyID()]._mesCas[nomCas];
+ HOMARD::HOMARD_Cas_var myCase = myStudyContext._mesCas[nomCas];
ASSERT(!CORBA::is_nil(myCase));
// B. Les repertoires
throw SALOME::SALOME_Exception(es);
return 2;
};
- HOMARD::HOMARD_Hypothesis_var myHypo = myContextMap[GetCurrentStudyID()]._mesHypotheses[nomHypo];
+ HOMARD::HOMARD_Hypothesis_var myHypo = myStudyContext._mesHypotheses[nomHypo];
ASSERT(!CORBA::is_nil(myHypo));
// B. L'iteration parent
const char* nomIterationParent = myIteration->GetIterParentName();
- HOMARD::HOMARD_Iteration_var myIterationParent = myContextMap[GetCurrentStudyID()]._mesIterations[nomIterationParent];
+ HOMARD::HOMARD_Iteration_var myIterationParent = myStudyContext._mesIterations[nomIterationParent];
ASSERT(!CORBA::is_nil(myIterationParent));
// Si l'iteration parent n'est pas calculee, on le fait (recursivite amont)
if ( myIterationParent->GetState() == 1 )
// Le sous-repertoire de l'iteration precedente
const char* nomIterationParent = myIteration->GetIterParentName();
- HOMARD::HOMARD_Iteration_var myIterationParent = myContextMap[GetCurrentStudyID()]._mesIterations[nomIterationParent];
+ HOMARD::HOMARD_Iteration_var myIterationParent = myStudyContext._mesIterations[nomIterationParent];
const char* nomDirItPa = myIterationParent->GetDirNameLoc();
std::stringstream DirComputePa ;
DirComputePa << nomDirCase << "/" << nomDirItPa;
{
std::string ZoneName = std::string((*ListZone)[iaux]);
MESSAGE ( "... ZoneName = " << ZoneName);
- HOMARD::HOMARD_Zone_var myZone = myContextMap[GetCurrentStudyID()]._mesZones[ZoneName];
+ HOMARD::HOMARD_Zone_var myZone = myStudyContext._mesZones[ZoneName];
ASSERT(!CORBA::is_nil(myZone));
int ZoneType = myZone->GetType();
if ( A_faire == 1 )
{
// 2.2.1. Caracteristiques de la frontiere
- HOMARD::HOMARD_Boundary_var myBoundary = myContextMap[GetCurrentStudyID()]._mesBoundarys[BoundaryName];
+ HOMARD::HOMARD_Boundary_var myBoundary = myStudyContext._mesBoundarys[BoundaryName];
ASSERT(!CORBA::is_nil(myBoundary));
int BoundaryType = myBoundary->GetType();
MESSAGE ( "... BoundaryType = " << BoundaryType );
{
std::string BoundaryName = std::string((*ListBoundaryGroupType)[NumBoundary]);
MESSAGE ( "... BoundaryName = " << BoundaryName);
- HOMARD::HOMARD_Boundary_var myBoundary = myContextMap[GetCurrentStudyID()]._mesBoundarys[BoundaryName];
+ HOMARD::HOMARD_Boundary_var myBoundary = myStudyContext._mesBoundarys[BoundaryName];
ASSERT(!CORBA::is_nil(myBoundary));
int BoundaryType = myBoundary->GetType();
MESSAGE ( "... BoundaryType = " << BoundaryType );
// Publications
//===========================================================================
//===========================================================================
-SALOMEDS::SObject_ptr HOMARD_Gen_i::PublishInStudy(SALOMEDS::Study_ptr theStudy,
- SALOMEDS::SObject_ptr theSObject,
+SALOMEDS::SObject_ptr HOMARD_Gen_i::PublishInStudy(SALOMEDS::SObject_ptr theSObject,
CORBA::Object_ptr theObject,
const char* theName)
{
MESSAGE("PublishInStudy pour " << theName);
SALOMEDS::SObject_var aResultSO;
- if (CORBA::is_nil(theStudy))
+ if (CORBA::is_nil(myStudy))
{
SALOME::ExceptionStruct es;
es.type = SALOME::BAD_PARAM;
HOMARD::HOMARD_YACS_var aYACS = HOMARD::HOMARD_YACS::_narrow(theObject);
HOMARD::HOMARD_Zone_var aZone = HOMARD::HOMARD_Zone::_narrow(theObject);
- addInStudy(theStudy);
+ UpdateStudy();
// Controle de la non publication d'un objet de meme nom
if ( (!aBoundary->_is_nil()) || (!aHypo->_is_nil()) || (!aYACS->_is_nil()) || (!aZone->_is_nil()) )
{
- SALOMEDS::Study::ListOfSObject_var listSO = theStudy->FindObjectByName(theName, ComponentDataType());
+ SALOMEDS::Study::ListOfSObject_var listSO = myStudy->FindObjectByName(theName, ComponentDataType());
if (listSO->length() >= 1)
{
MESSAGE("This name "<<theName<<" is already used "<<listSO->length()<<" time(s)");
}
// Caracteristiques de l'etude
- SALOMEDS::StudyBuilder_var aStudyBuilder = theStudy->NewBuilder();
+ SALOMEDS::StudyBuilder_var aStudyBuilder = myStudy->NewBuilder();
aStudyBuilder->NewCommand();
if(!aBoundary->_is_nil())
- aResultSO = PublishBoundaryInStudy(theStudy, aStudyBuilder, aBoundary, theName);
+ aResultSO = PublishBoundaryInStudy(aStudyBuilder, aBoundary, theName);
else if(!aCase->_is_nil())
- aResultSO = PublishCaseInStudy(theStudy, aStudyBuilder, aCase, theName);
+ aResultSO = PublishCaseInStudy(aStudyBuilder, aCase, theName);
else if(!aHypo->_is_nil())
- aResultSO = PublishHypotheseInStudy(theStudy, aStudyBuilder, aHypo, theName);
+ aResultSO = PublishHypotheseInStudy(aStudyBuilder, aHypo, theName);
else if(!aYACS->_is_nil())
- aResultSO = PublishYACSInStudy(theStudy, aStudyBuilder, aYACS, theName);
+ aResultSO = PublishYACSInStudy(aStudyBuilder, aYACS, theName);
else if(!aZone->_is_nil())
- aResultSO = PublishZoneInStudy(theStudy, aStudyBuilder, aZone, theName);
+ aResultSO = PublishZoneInStudy(aStudyBuilder, aZone, theName);
aStudyBuilder->CommitCommand();
return aResultSO._retn();
};
//=============================================================================
-SALOMEDS::SObject_ptr HOMARD_Gen_i::PublishBoundaryInStudy(SALOMEDS::Study_ptr theStudy,
- SALOMEDS::StudyBuilder_var aStudyBuilder,
+SALOMEDS::SObject_ptr HOMARD_Gen_i::PublishBoundaryInStudy( SALOMEDS::StudyBuilder_var aStudyBuilder,
HOMARD::HOMARD_Boundary_ptr theObject, const char* theName)
{
MESSAGE("PublishBoundaryStudy pour "<<theName);
SALOMEDS::SObject_var aResultSO;
// Caracteristique de la Boundary
- HOMARD::HOMARD_Boundary_var myBoundary = myContextMap[GetCurrentStudyID()]._mesBoundarys[theName];
+ HOMARD::HOMARD_Boundary_var myBoundary = myStudyContext._mesBoundarys[theName];
// On recupere le module pere dans l etude
- SALOMEDS::SComponent_var theFatherHomard = theStudy->FindComponent(ComponentDataType());
+ SALOMEDS::SComponent_var theFatherHomard = myStudy->FindComponent(ComponentDataType());
if (theFatherHomard->_is_nil())
{
MESSAGE("theFatherHomard->_is_nil()");
return aResultSO._retn();
}
//=============================================================================
-SALOMEDS::SObject_ptr HOMARD_Gen_i::PublishCaseInStudy(SALOMEDS::Study_ptr theStudy,
- SALOMEDS::StudyBuilder_var aStudyBuilder,
+SALOMEDS::SObject_ptr HOMARD_Gen_i::PublishCaseInStudy(SALOMEDS::StudyBuilder_var aStudyBuilder,
HOMARD::HOMARD_Cas_ptr theObject, const char* theName)
{
MESSAGE("PublishCaseInStudy pour "<<theName);
MESSAGE("HOMARD_Gen_i::theObject->_is_nil()");
return aResultSO._retn();
}
- if (theStudy->_is_nil()) {
- MESSAGE("HOMARD_Gen_i::theStudy->_is_nil()");
+ if (myStudy->_is_nil()) {
+ MESSAGE("HOMARD_Gen_i::myStudy->_is_nil()");
return aResultSO._retn();
}
// On recupere le module pere dans l etude
- SALOMEDS::SComponent_var theFatherHomard = theStudy->FindComponent(ComponentDataType());
+ SALOMEDS::SComponent_var theFatherHomard = myStudy->FindComponent(ComponentDataType());
if (theFatherHomard->_is_nil())
{
MESSAGE("theFatherHomard->_is_nil()");
return aResultSO._retn();
}
//=============================================================================
-SALOMEDS::SObject_ptr HOMARD_Gen_i::PublishHypotheseInStudy(SALOMEDS::Study_ptr theStudy,
- SALOMEDS::StudyBuilder_var aStudyBuilder,
+SALOMEDS::SObject_ptr HOMARD_Gen_i::PublishHypotheseInStudy(SALOMEDS::StudyBuilder_var aStudyBuilder,
HOMARD::HOMARD_Hypothesis_ptr theObject, const char* theName)
{
MESSAGE("PublishHypotheseInStudy pour "<<theName);
// On recupere le module pere dans l etude
// On ajoute la categorie des hypotheses dans l etude si necessaire
- SALOMEDS::SComponent_var theFatherHomard = theStudy->FindComponent(ComponentDataType());
+ SALOMEDS::SComponent_var theFatherHomard = myStudy->FindComponent(ComponentDataType());
if (theFatherHomard->_is_nil())
{
MESSAGE("theFatherHomard->_is_nil()");
return aResultSO._retn();
}
//=============================================================================
-SALOMEDS::SObject_ptr HOMARD_Gen_i::PublishYACSInStudy(SALOMEDS::Study_ptr theStudy,
- SALOMEDS::StudyBuilder_var aStudyBuilder,
+SALOMEDS::SObject_ptr HOMARD_Gen_i::PublishYACSInStudy(SALOMEDS::StudyBuilder_var aStudyBuilder,
HOMARD::HOMARD_YACS_ptr theObject, const char* theName)
{
MESSAGE("PublishYACSInStudy pour "<<theName);
// On recupere le module pere dans l etude
// On ajoute la categorie des schemas YACS dans l etude si necessaire
- SALOMEDS::SComponent_var theFatherHomard = theStudy->FindComponent(ComponentDataType());
+ SALOMEDS::SComponent_var theFatherHomard = myStudy->FindComponent(ComponentDataType());
if (theFatherHomard->_is_nil())
{
MESSAGE("theFatherHomard->_is_nil()");
}
//=============================================================================
-SALOMEDS::SObject_ptr HOMARD_Gen_i::PublishZoneInStudy(SALOMEDS::Study_ptr theStudy,
- SALOMEDS::StudyBuilder_var aStudyBuilder,
+SALOMEDS::SObject_ptr HOMARD_Gen_i::PublishZoneInStudy(SALOMEDS::StudyBuilder_var aStudyBuilder,
HOMARD::HOMARD_Zone_ptr theObject, const char* theName)
{
MESSAGE("PublishZoneStudy pour "<<theName);
MESSAGE("PublishZoneInStudy : theObject->_is_nil()");
return aResultSO._retn();
}
- if (theStudy->_is_nil())
+ if (myStudy->_is_nil())
{
- MESSAGE("PublishZoneInStudy : theStudy->_is_nil()");
+ MESSAGE("PublishZoneInStudy : myStudy->_is_nil()");
return aResultSO._retn();
}
- SALOMEDS::SComponent_var theFatherHomard = theStudy->FindComponent(ComponentDataType());
+ SALOMEDS::SComponent_var theFatherHomard = myStudy->FindComponent(ComponentDataType());
if (theFatherHomard->_is_nil())
{
MESSAGE("PublishZoneInStudy : theFatherHomard->_is_nil()");
}
// Caracteristique de la zone
- HOMARD::HOMARD_Zone_var myZone = myContextMap[GetCurrentStudyID()]._mesZones[theName];
+ HOMARD::HOMARD_Zone_var myZone = myStudyContext._mesZones[theName];
CORBA::Long ZoneType = myZone->GetType();
// On ajoute la categorie des zones dans l etude si necessaire
{
MESSAGE ( "PublishBoundaryUnderCase : CaseName = " << CaseName << ", BoundaryName= " << BoundaryName );
- HOMARD::HOMARD_Cas_var myCase = myContextMap[GetCurrentStudyID()]._mesCas[CaseName];
+ HOMARD::HOMARD_Cas_var myCase = myStudyContext._mesCas[CaseName];
ASSERT(!CORBA::is_nil(myCase));
- SALOMEDS::SObject_var aCaseSO = SALOMEDS::SObject::_narrow(myCurrentStudy->FindObjectIOR(_orb->object_to_string(myCase)));
+ SALOMEDS::SObject_var aCaseSO = SALOMEDS::SObject::_narrow(myStudy->FindObjectIOR(_orb->object_to_string(myCase)));
ASSERT(!CORBA::is_nil(aCaseSO));
- HOMARD::HOMARD_Boundary_var myBoundary = myContextMap[GetCurrentStudyID()]._mesBoundarys[BoundaryName];
+ HOMARD::HOMARD_Boundary_var myBoundary = myStudyContext._mesBoundarys[BoundaryName];
ASSERT(!CORBA::is_nil(myBoundary));
- SALOMEDS::SObject_var aBoundarySO = SALOMEDS::SObject::_narrow(myCurrentStudy->FindObjectIOR(_orb->object_to_string(myBoundary)));
+ SALOMEDS::SObject_var aBoundarySO = SALOMEDS::SObject::_narrow(myStudy->FindObjectIOR(_orb->object_to_string(myBoundary)));
ASSERT(!CORBA::is_nil(aBoundarySO));
- SALOMEDS::StudyBuilder_var aStudyBuilder = myCurrentStudy->NewBuilder();
+ SALOMEDS::StudyBuilder_var aStudyBuilder = myStudy->NewBuilder();
aStudyBuilder->NewCommand();
{
MESSAGE ( "PublishCaseUnderYACS : nomYACS = " << nomYACS << ", CaseName= " << CaseName );
- HOMARD::HOMARD_YACS_var myYACS = myContextMap[GetCurrentStudyID()]._mesYACSs[nomYACS];
+ HOMARD::HOMARD_YACS_var myYACS = myStudyContext._mesYACSs[nomYACS];
ASSERT(!CORBA::is_nil(myYACS));
- SALOMEDS::SObject_var aYACSSO = SALOMEDS::SObject::_narrow(myCurrentStudy->FindObjectIOR(_orb->object_to_string(myYACS)));
+ SALOMEDS::SObject_var aYACSSO = SALOMEDS::SObject::_narrow(myStudy->FindObjectIOR(_orb->object_to_string(myYACS)));
ASSERT(!CORBA::is_nil(aYACSSO));
- HOMARD::HOMARD_Cas_var myCase = myContextMap[GetCurrentStudyID()]._mesCas[CaseName];
+ HOMARD::HOMARD_Cas_var myCase = myStudyContext._mesCas[CaseName];
ASSERT(!CORBA::is_nil(myCase));
- SALOMEDS::SObject_var aCaseSO = SALOMEDS::SObject::_narrow(myCurrentStudy->FindObjectIOR(_orb->object_to_string(myCase)));
+ SALOMEDS::SObject_var aCaseSO = SALOMEDS::SObject::_narrow(myStudy->FindObjectIOR(_orb->object_to_string(myCase)));
ASSERT(!CORBA::is_nil(aCaseSO));
- SALOMEDS::StudyBuilder_var aStudyBuilder = myCurrentStudy->NewBuilder();
+ SALOMEDS::StudyBuilder_var aStudyBuilder = myStudy->NewBuilder();
aStudyBuilder->NewCommand();
// Option = 1 : fichier issu d'une execution HOMARD
{
MESSAGE( "PublishResultInSmesh " << NomFich << ", avec Option = " << Option);
- if (CORBA::is_nil(myCurrentStudy))
+ if (CORBA::is_nil(myStudy))
{
SALOME::ExceptionStruct es;
es.type = SALOME::BAD_PARAM;
};
// Le module SMESH est-il actif ?
- SALOMEDS::SObject_var aSmeshSO = myCurrentStudy->FindComponent("SMESH");
+ SALOMEDS::SObject_var aSmeshSO = myStudy->FindComponent("SMESH");
//
if (!CORBA::is_nil(aSmeshSO))
{
// On verifie que le fichier n est pas deja publie
- SALOMEDS::ChildIterator_var aIter = myCurrentStudy->NewChildIterator(aSmeshSO);
+ SALOMEDS::ChildIterator_var aIter = myStudy->NewChildIterator(aSmeshSO);
for (; aIter->More(); aIter->Next())
{
SALOMEDS::SObject_var aSO = aIter->Value();
SALOME_LifeCycleCORBA* myLCC = new SALOME_LifeCycleCORBA(_NS);
SMESH::SMESH_Gen_var aSmeshEngine = SMESH::SMESH_Gen::_narrow(myLCC->FindOrLoad_Component("FactoryServer","SMESH"));
ASSERT(!CORBA::is_nil(aSmeshEngine));
- aSmeshEngine->SetCurrentStudy(myCurrentStudy);
+ aSmeshEngine->UpdateStudy();
SMESH::DriverMED_ReadStatus theStatus;
//aSmeshEngine->CreateMeshesFromMED(NomFich, theStatus);
{
MESSAGE( ". Mise a jour des attributs du maillage");
SMESH::SMESH_Mesh_var monMaillage= (*mesMaillages)[i];
- SALOMEDS::SObject_var aSO=SALOMEDS::SObject::_narrow(myCurrentStudy->FindObjectIOR(_orb->object_to_string(monMaillage)));
- SALOMEDS::StudyBuilder_var aStudyBuilder = myCurrentStudy->NewBuilder();
+ SALOMEDS::SObject_var aSO=SALOMEDS::SObject::_narrow(myStudy->FindObjectIOR(_orb->object_to_string(monMaillage)));
+ SALOMEDS::StudyBuilder_var aStudyBuilder = myStudy->NewBuilder();
SALOMEDS::GenericAttribute_var aGAttr = aStudyBuilder->FindOrCreateAttribute(aSO, "AttributeExternalFileDef");
SALOMEDS::AttributeExternalFileDef_var anAttr = SALOMEDS::AttributeExternalFileDef::_narrow(aGAttr);
anAttr->SetValue(NomFich);
void HOMARD_Gen_i::DeleteResultInSmesh(std::string NomFich, std::string MeshName)
{
MESSAGE ("DeleteResultInSmesh pour le maillage " << MeshName << " dans le fichier " << NomFich );
- if (CORBA::is_nil(myCurrentStudy))
+ if (CORBA::is_nil(myStudy))
{
SALOME::ExceptionStruct es;
es.type = SALOME::BAD_PARAM;
};
// Le module SMESH est-il actif ?
- SALOMEDS::SObject_var aSmeshSO = myCurrentStudy->FindComponent("SMESH");
+ SALOMEDS::SObject_var aSmeshSO = myStudy->FindComponent("SMESH");
//
if (CORBA::is_nil(aSmeshSO))
{
return ;
};
// On verifie que le fichier est deja publie
- SALOMEDS::StudyBuilder_var myBuilder = myCurrentStudy->NewBuilder();
- SALOMEDS::ChildIterator_var aIter = myCurrentStudy->NewChildIterator(aSmeshSO);
+ SALOMEDS::StudyBuilder_var myBuilder = myStudy->NewBuilder();
+ SALOMEDS::ChildIterator_var aIter = myStudy->NewChildIterator(aSmeshSO);
for (; aIter->More(); aIter->Next())
{
SALOMEDS::SObject_var aSO = aIter->Value();
void HOMARD_Gen_i::PublishMeshIterInSmesh(const char* NomIter)
{
MESSAGE( "PublishMeshIterInSmesh " << NomIter);
- HOMARD::HOMARD_Iteration_var myIteration = myContextMap[GetCurrentStudyID()]._mesIterations[NomIter];
+ HOMARD::HOMARD_Iteration_var myIteration = myStudyContext._mesIterations[NomIter];
- SALOMEDS::SObject_var aIterSO=SALOMEDS::SObject::_narrow(myCurrentStudy->FindObjectIOR(_orb->object_to_string(myIteration)));
+ SALOMEDS::SObject_var aIterSO=SALOMEDS::SObject::_narrow(myStudy->FindObjectIOR(_orb->object_to_string(myIteration)));
if (CORBA::is_nil(myIteration))
{
SALOME::ExceptionStruct es;
void HOMARD_Gen_i::PublishFileUnderIteration(const char* NomIter, const char* NomFich, const char* Commentaire)
{
// MESSAGE ("PublishFileUnderIteration pour l'iteration " << NomIter << " du fichier " << NomFich << " avec le commentaire " << Commentaire );
- HOMARD::HOMARD_Iteration_var myIteration = myContextMap[GetCurrentStudyID()]._mesIterations[NomIter];
+ HOMARD::HOMARD_Iteration_var myIteration = myStudyContext._mesIterations[NomIter];
- SALOMEDS::SObject_var aIterSO=SALOMEDS::SObject::_narrow(myCurrentStudy->FindObjectIOR(_orb->object_to_string(myIteration)));
+ SALOMEDS::SObject_var aIterSO=SALOMEDS::SObject::_narrow(myStudy->FindObjectIOR(_orb->object_to_string(myIteration)));
if (CORBA::is_nil(myIteration))
{
SALOME::ExceptionStruct es;
return ;
};
- SALOMEDS::StudyBuilder_var aStudyBuilder = myCurrentStudy->NewBuilder();
+ SALOMEDS::StudyBuilder_var aStudyBuilder = myStudy->NewBuilder();
aStudyBuilder->NewCommand();
void HOMARD_Gen_i::PublishFileUnderYACS(const char* nomYACS, const char* NomFich, const char* Commentaire)
{
// MESSAGE ("PublishFileUnderYACS pour le schema " << nomYACS << " du fichier " << NomFich << " avec le commentaire " << Commentaire );
- HOMARD::HOMARD_YACS_var myYACS = myContextMap[GetCurrentStudyID()]._mesYACSs[nomYACS];
+ HOMARD::HOMARD_YACS_var myYACS = myStudyContext._mesYACSs[nomYACS];
- SALOMEDS::SObject_var aYACSSO=SALOMEDS::SObject::_narrow(myCurrentStudy->FindObjectIOR(_orb->object_to_string(myYACS)));
+ SALOMEDS::SObject_var aYACSSO=SALOMEDS::SObject::_narrow(myStudy->FindObjectIOR(_orb->object_to_string(myYACS)));
if (CORBA::is_nil(myYACS))
{
SALOME::ExceptionStruct es;
return ;
};
- SALOMEDS::StudyBuilder_var aStudyBuilder = myCurrentStudy->NewBuilder();
+ SALOMEDS::StudyBuilder_var aStudyBuilder = myStudy->NewBuilder();
aStudyBuilder->NewCommand();
INFOS ( ". MeshFile : " << MeshFile);
// A. Controle du nom :
- if ((myContextMap[GetCurrentStudyID()]._mesYACSs).find(nomYACS) != (myContextMap[GetCurrentStudyID()]._mesYACSs).end())
+ if ((myStudyContext._mesYACSs).find(nomYACS) != (myStudyContext._mesYACSs).end())
{
SALOME::ExceptionStruct es;
es.type = SALOME::BAD_PARAM;
myYACS->SetName( nomYACS ) ;
// C. Enregistrement
- myContextMap[GetCurrentStudyID()]._mesYACSs[nomYACS] = myYACS;
+ myStudyContext._mesYACSs[nomYACS] = myYACS;
SALOMEDS::SObject_var aSO;
- SALOMEDS::SObject_var aResultSO=PublishInStudy(myCurrentStudy, aSO, myYACS, nomYACS);
+ SALOMEDS::SObject_var aResultSO=PublishInStudy(aSO, myYACS, nomYACS);
PublishCaseUnderYACS(nomYACS, nomCas);
{
INFOS ( "YACSWrite : Ecriture de " << nomYACS );
// Le repertoire du cas
- HOMARD::HOMARD_YACS_var myYACS = myContextMap[GetCurrentStudyID()]._mesYACSs[nomYACS];
+ HOMARD::HOMARD_YACS_var myYACS = myStudyContext._mesYACSs[nomYACS];
ASSERT(!CORBA::is_nil(myYACS));
// Le nom du fichier du schema
std::string XMLFile ;
// B. L'objet YACS
// B.1. L'objet
- HOMARD::HOMARD_YACS_var myYACS = myContextMap[GetCurrentStudyID()]._mesYACSs[nomYACS];
+ HOMARD::HOMARD_YACS_var myYACS = myStudyContext._mesYACSs[nomYACS];
ASSERT(!CORBA::is_nil(myYACS));
// B.2. Les caracteristiques
std::string DirName = myYACS->GetDirName() ;
// C. Le cas
// C.1. L'objet cas
const char* nomCas = myYACS->GetCaseName();
- HOMARD::HOMARD_Cas_var myCase = myContextMap[GetCurrentStudyID()]._mesCas[nomCas];
+ HOMARD::HOMARD_Cas_var myCase = myStudyContext._mesCas[nomCas];
ASSERT(!CORBA::is_nil(myCase));
// C.2. Les instructions python associees au cas
CORBA::String_var dumpCorbaCase = myCase->GetDumpPython();
// E.1. La structure
std::string nomHypo = Iter1->GetHypoName();
MESSAGE (". nomHypo = " << nomHypo);
- HOMARD::HOMARD_Hypothesis_var myHypo = myContextMap[GetCurrentStudyID()]._mesHypotheses[nomHypo];
+ HOMARD::HOMARD_Hypothesis_var myHypo = myStudyContext._mesHypotheses[nomHypo];
ASSERT(!CORBA::is_nil(myHypo));
// E.2. Les caracteristiques de l'adaptation
HOMARD::listeTypes* ListTypes = myHypo->GetAdapRefinUnRef();
// 1. Reperage de la zone
std::string ZoneName = std::string((*ListZone)[iaux]);
MESSAGE ( "\n. ZoneName = " << ZoneName << " - " <<iaux);
- HOMARD::HOMARD_Zone_var myZone = myContextMap[GetCurrentStudyID()]._mesZones[ZoneName];
+ HOMARD::HOMARD_Zone_var myZone = myStudyContext._mesZones[ZoneName];
ASSERT(!CORBA::is_nil(myZone));
// 2. Les instructions python associees a la zone
// La premiere ligne est un commentaire a eliminer
if ( A_faire == 1 )
{
// 1. Caracteristiques de la frontiere
- HOMARD::HOMARD_Boundary_var myBoundary = myContextMap[GetCurrentStudyID()]._mesBoundarys[BoundaryName];
+ HOMARD::HOMARD_Boundary_var myBoundary = myStudyContext._mesBoundarys[BoundaryName];
ASSERT(!CORBA::is_nil(myBoundary));
// 2. Les instructions python associees a la frontiere
// La premiere ligne est un commentaire a eliminer
std::string tmpDir = isMultiFile ? std::string(theURL) : SALOMEDS_Tool::GetTmpDir();
SALOMEDS::Study_var aStudy = theComponent->GetStudy();
- StudyContext& context = myContextMap[ aStudy->StudyId() ];
+ StudyContext& context = myStudyContext;
// HOMARD data file name
std::string aFileName = "";
SALOMEDS::Study_var aStudy = theComponent->GetStudy();
// set current study
- if (myCurrentStudy->_is_nil() || aStudy->StudyId() != myCurrentStudy->StudyId())
- SetCurrentStudy(aStudy);
+ if (myStudy->_is_nil())
+ UpdateStudy();
// get temporary directory name
std::string tmpDir = isMultiFile ? std::string(theURL) : SALOMEDS_Tool::GetTmpDir();
aFileName = SALOMEDS_Tool::GetNameFromPath(aStudy->URL());
aFileName = tmpDir + aFileName + "_HOMARD.dat";
- StudyContext& context = myContextMap[ aStudy->StudyId() ];
+ StudyContext& context = myStudyContext;
// save data
// -> create file
//===========================================================================
void HOMARD_Gen_i::Close(SALOMEDS::SComponent_ptr theComponent)
{
- if (theComponent->GetStudy()->StudyId() == GetCurrentStudyID()) {
- // clearing study context should be done here:
- // - destroy all servants and related CORBA objects
- // ... (TODO)
- // - remove context from myContextMap
- myContextMap.erase(theComponent->GetStudy()->StudyId());
- // - nullify myCurrentStudy
- myCurrentStudy = SALOMEDS::Study::_nil();
- }
+ if (theComponent->GetStudy())
+ // - nullify myStudy
+ myStudy = SALOMEDS::Study::_nil();
};
//===========================================================================
{
CORBA::String_var aString("");
if (!CORBA::is_nil(theSObject) && strcmp(IORString, "") != 0) {
- StudyContext context = myContextMap[ theSObject->GetStudy()->StudyId() ];
+ StudyContext context = myStudyContext;
CORBA::Object_var anObj = _orb->string_to_object(IORString);
if (!CORBA::is_nil(anObj)) {
PortableServer::ServantBase_var aServant = GetServant(anObj);
{
CORBA::String_var aString("");
if (!CORBA::is_nil(theSObject) && strcmp(aLocalPersistentID, "") != 0) {
- StudyContext context = myContextMap[ theSObject->GetStudy()->StudyId() ];
+ StudyContext context = myStudyContext;
int id = atoi(aLocalPersistentID);
if (id > 0 && context._idmap.find(id) != context._idmap.end()) {
CORBA::Object_var object = _poa->servant_to_reference(context._idmap[ id ]);
//===========================================================================
CORBA::Boolean HOMARD_Gen_i::CanPublishInStudy(CORBA::Object_ptr theIOR)
{
- if(CORBA::is_nil(myCurrentStudy))
+ if(CORBA::is_nil(myStudy))
return false;
HOMARD::HOMARD_Cas_var aCas = HOMARD::HOMARD_Cas::_narrow(theIOR);
if( isMultiFile )
aScript += "import salome\n";
aScript += "homard = salome.lcc.FindOrLoadComponent('FactoryServer','HOMARD')\n";
- if( isMultiFile ) {
- aScript += "def RebuildData(theStudy):\n";
- aScript += "\thomard.SetCurrentStudy(theStudy)\n";
- }
- else
- aScript += "\thomard.SetCurrentStudy(salome.myStudy)\n";
+ aScript += "\thomard.UpdateStudy()\n";
MESSAGE (". Au depart \n"<<aScript);
- if (myContextMap[GetCurrentStudyID()]._mesBoundarys.size() > 0)
+ if (myStudyContext._mesBoundarys.size() > 0)
{
MESSAGE (". Ecritures des frontieres");
aScript += "#\n# Creation of the boundaries";
aScript += "\n# ==========================";
}
std::map<std::string, HOMARD::HOMARD_Boundary_var>::const_iterator it_boundary;
- for (it_boundary = myContextMap[GetCurrentStudyID()]._mesBoundarys.begin();
- it_boundary != myContextMap[GetCurrentStudyID()]._mesBoundarys.end(); ++it_boundary)
+ for (it_boundary = myStudyContext._mesBoundarys.begin();
+ it_boundary != myStudyContext._mesBoundarys.end(); ++it_boundary)
{
HOMARD::HOMARD_Boundary_var maBoundary = (*it_boundary).second;
CORBA::String_var dumpCorbaBoundary = maBoundary->GetDumpPython();
}
- if (myContextMap[GetCurrentStudyID()]._mesZones.size() > 0)
+ if (myStudyContext._mesZones.size() > 0)
{
MESSAGE (". Ecritures des zones");
aScript += "#\n# Creation of the zones";
aScript += "\n# =====================";
}
std::map<std::string, HOMARD::HOMARD_Zone_var>::const_iterator it_zone;
- for ( it_zone = myContextMap[GetCurrentStudyID()]._mesZones.begin();
- it_zone != myContextMap[GetCurrentStudyID()]._mesZones.end(); ++it_zone)
+ for ( it_zone = myStudyContext._mesZones.begin();
+ it_zone != myStudyContext._mesZones.end(); ++it_zone)
{
HOMARD::HOMARD_Zone_var myZone = (*it_zone).second;
CORBA::String_var dumpCorbaZone = myZone->GetDumpPython();
}
- if (myContextMap[GetCurrentStudyID()]._mesHypotheses.size() > 0)
+ if (myStudyContext._mesHypotheses.size() > 0)
{
MESSAGE (". Ecritures des hypotheses");
aScript += "#\n# Creation of the hypotheses";
aScript += "\n# ==========================";
}
std::map<std::string, HOMARD::HOMARD_Hypothesis_var>::const_iterator it_hypo;
- for ( it_hypo = myContextMap[GetCurrentStudyID()]._mesHypotheses.begin();
- it_hypo != myContextMap[GetCurrentStudyID()]._mesHypotheses.end(); it_hypo++)
+ for ( it_hypo = myStudyContext._mesHypotheses.begin();
+ it_hypo != myStudyContext._mesHypotheses.end(); it_hypo++)
{
HOMARD::HOMARD_Hypothesis_var monHypo = (*it_hypo).second;
CORBA::String_var dumpCorbaHypo = monHypo->GetDumpPython();
}
- if (myContextMap[GetCurrentStudyID()]._mesCas.size() > 0)
+ if (myStudyContext._mesCas.size() > 0)
{
MESSAGE (". Ecritures des cas");
aScript += "#\n# Creation of the cases";
aScript += "\n# =====================";
}
std::map<std::string, HOMARD::HOMARD_Cas_var>::const_iterator it_cas;
- for (it_cas = myContextMap[GetCurrentStudyID()]._mesCas.begin();
- it_cas != myContextMap[GetCurrentStudyID()]._mesCas.end(); it_cas++)
+ for (it_cas = myStudyContext._mesCas.begin();
+ it_cas != myStudyContext._mesCas.end(); it_cas++)
{
std::string nomCas = (*it_cas).first;
std::string dumpCas = std::string("\n# Creation of the case ") ;
CORBA::String_var cIter0= myCase->GetIter0Name();
std::string iter0 = cIter0.in();
- HOMARD::HOMARD_Iteration_var myIteration = myContextMap[GetCurrentStudyID()]._mesIterations[iter0];
+ HOMARD::HOMARD_Iteration_var myIteration = myStudyContext._mesIterations[iter0];
CORBA::String_var cMesh0= myIteration->GetMeshFile();
std::string mesh0 = cMesh0.in();
CORBA::String_var cMeshName0= myIteration->GetMeshName();
};
- if (myContextMap[GetCurrentStudyID()]._mesIterations.size() > 0)
+ if (myStudyContext._mesIterations.size() > 0)
{
MESSAGE (". Ecritures des iterations");
aScript += "#\n# Creation of the iterations" ;
aScript += "\n# ==========================";
}
std::map<std::string, HOMARD::HOMARD_Iteration_var>::const_iterator it_iter;
- for (it_iter = myContextMap[GetCurrentStudyID()]._mesIterations.begin();
- it_iter != myContextMap[GetCurrentStudyID()]._mesIterations.end(); ++it_iter)
+ for (it_iter = myStudyContext._mesIterations.begin();
+ it_iter != myStudyContext._mesIterations.end(); ++it_iter)
{
HOMARD::HOMARD_Iteration_var aIter = (*it_iter).second;
CORBA::String_var dumpCorbaIter = aIter->GetDumpPython();
}
- if (myContextMap[GetCurrentStudyID()]._mesYACSs.size() > 0)
+ if (myStudyContext._mesYACSs.size() > 0)
{
MESSAGE (". Ecritures des schemas YACS");
aScript += "#\n# Creation of the schemas YACS";
aScript += "\n# ============================";
}
std::map<std::string, HOMARD::HOMARD_YACS_var>::const_iterator it_yacs;
- for ( it_yacs = myContextMap[GetCurrentStudyID()]._mesYACSs.begin();
- it_yacs != myContextMap[GetCurrentStudyID()]._mesYACSs.end(); ++it_yacs)
+ for ( it_yacs = myStudyContext._mesYACSs.begin();
+ it_yacs != myStudyContext._mesYACSs.end(); ++it_yacs)
{
HOMARD::HOMARD_YACS_var myYACS = (*it_yacs).second;
CORBA::String_var dumpCorbaYACS = myYACS->GetDumpPython();
void HOMARD_Gen_i::IsValidStudy( )
{
// MESSAGE( "IsValidStudy" );
- if (CORBA::is_nil(myCurrentStudy))
+ if (CORBA::is_nil(myStudy))
{
SALOME::ExceptionStruct es;
es.type = SALOME::BAD_PARAM;
{
std::string casename = std::string("") ;
std::map<std::string, HOMARD::HOMARD_Cas_var>::const_iterator it;
- for (it = myContextMap[GetCurrentStudyID()]._mesCas.begin();
- it != myContextMap[GetCurrentStudyID()]._mesCas.end(); it++)
+ for (it = myStudyContext._mesCas.begin();
+ it != myStudyContext._mesCas.end(); it++)
{
if (std::string(nomDir) == std::string(it->second->GetDirName()))
{
