//
#include "DSC_i.hxx"
+//#define MYDEBUG
+
Engines_DSC_i::
Engines_DSC_i(CORBA::ORB_ptr orb,
PortableServer::POA_ptr poa,
instanceName,
interfaceName)
{
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cerr << "--Engines_DSC_i: MARK 1 --" << instanceName << "----" << std::endl;
#endif
}
bool regist) :
Engines_Component_i(orb, poa, container, instanceName, interfaceName,notif,regist)
{
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cerr << "--Engines_DSC_i: MARK 1 --" << instanceName << "----" << std::endl;
#endif
}
#include <string>
#include "DSC_interface.hxx"
+//#define MYDEBUG
+
Engines_DSC_interface::Engines_DSC_interface() {}
Engines_DSC_interface::~Engines_DSC_interface()
Engines::DSC::BadPortType BPT;
BPT.expected = CORBA::string_dup("Expected a uses port");
BPT.received = CORBA::string_dup((std::string("Received a provides/none port : ")+uses_port_name).c_str());
+#ifdef MYDEBUG
std::cout << "---- DSC_Interface : MARK 1 ---- exception : " << uses_port_name << "----" << std::endl;
+#endif
throw BPT;
}
}
else
{
+#ifdef MYDEBUG
std::cout << "---- DSC_Interface : MARK 2 ---- exception : " << uses_port_name << "----" << std::endl;
+#endif
throw Engines::DSC::PortNotConnected();
}
#include "DisplayPair.hxx"
//
+//#define MYDEBUG
+
// Suppose que le container est trié
template < typename T > struct AdjacentFunctor {
// Suppose que les valeurs passées en paramètres sont triées par ordre croissant
bool operator()(const T &v1) {
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "AdjacentFunctor: " << _minValue << _maxValue << std::endl;
std::cout << "AdjacentFunctor: " << _min << _max << std::endl;
#endif
if ( v1 <= _minValue && v1 >= _maxValue)
{
_equal= true;
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "AdjacentFunctor: _equal : " << v1 << std::endl;
#endif
return true;
if ( v1 < _minValue )
{
_min=v1;_minFound=true;
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "AdjacentFunctor: _minFound : " <<_min << std::endl;
#endif
}
else if ( v1 > _maxValue )
{
_max=v1;_maxFound=true;
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "AdjacentFunctor: _maxFound : " <<_max << std::endl;
#endif
}
bool isEqual() const { return _equal;}
bool isBounded() const { return _minFound && _maxFound;}
bool getBounds(TNoConst & min, TNoConst & max) const {
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "_minFound : " <<_minFound << ", _maxFound " << _maxFound << std::endl;
#endif
if (_minFound && _maxFound ) { min=_min; max=_max; return true; }
#include <string>
#include <exception>
-//#define _DEBUG_
-
PySupervCompo::PySupervCompo( CORBA::ORB_ptr orb,
PortableServer::POA_ptr poa,
Engines::Container_ptr contain,
extern "C"
{
+ void cp_exit(int);
+ void setDependency(provides_port*, char*, CalciumTypes::DependencyType);
+
void cp_exit(int err)
{
throw CalciumException(err,LOC("Abort coupling"));
void create_calcium_port(Superv_Component_i* compo,char* name,char* type,char *mode,char* depend)
{
-#ifdef _DEBUG_
- std::cerr << "create_calcium_port: " << name << " " << type << " " << mode << " " << depend << std::endl;
-#endif
+ MESSAGE( "create_calcium_port: " << name << " " << type << " " << mode << " " << depend );
if(std::string(mode) == "IN")
{
#include <stdio.h>
-#ifdef _DEBUG_
+//#define MYDEBUG
+#ifdef MYDEBUG
#define DEBTRACE(msg) {std::cerr<<std::flush<<__FILE__<<" ["<<__LINE__<<"] : "<<msg<<std::endl<<std::flush;}
#else
#define DEBTRACE(msg)
CalciumTypes::DependencyType CalciumCouplingPolicy::getDependencyType () const { return _dependencyType;}
void CalciumCouplingPolicy::setStorageLevel (size_t storageLevel) {
-#ifdef _DEBUG_
- std::cerr << "CalciumCouplingPolicy::setStorageLevel: " << storageLevel << std::endl;
-#endif
+ MESSAGE( "CalciumCouplingPolicy::setStorageLevel: " << storageLevel );
if ( storageLevel < 1 && (storageLevel != CalciumTypes::UNLIMITED_STORAGE_LEVEL) )
throw CalciumException(CalciumTypes::CPRENA,LOC("Un niveau < 1 n'est pas autorisé"));
_storageLevel = storageLevel;
}
size_t CalciumCouplingPolicy::getStorageLevel () const {return _storageLevel;}
void CalciumCouplingPolicy::setDateCalSchem (CalciumTypes::DateCalSchem dateCalSchem) {
-#ifdef _DEBUG_
- std::cerr << "CalciumCouplingPolicy::setDateCalSchem: " << dateCalSchem << std::endl;
-#endif
+ MESSAGE( "CalciumCouplingPolicy::setDateCalSchem: " << dateCalSchem );
if ( _dependencyType != CalciumTypes::TIME_DEPENDENCY )
throw CalciumException(CalciumTypes::CPITVR,LOC("Il est impossible de positionner un schéma temporel sur un port qui n'est pas en dépendance temporelle"));
_dateCalSchem = dateCalSchem;
CalciumTypes::DateCalSchem CalciumCouplingPolicy::getDateCalSchem () const { return _dateCalSchem; }
void CalciumCouplingPolicy::setAlpha(double alpha) {
-#ifdef _DEBUG_
- std::cerr << "CalciumCouplingPolicy::setAlpha: " << alpha << std::endl;
-#endif
+ MESSAGE( "CalciumCouplingPolicy::setAlpha: " << alpha );
if ( _dependencyType != CalciumTypes::TIME_DEPENDENCY )
throw CalciumException(CalciumTypes::CPITVR,LOC("Il est impossible de positionner alpha sur un port qui n'est pas en dépendance temporelle"));
- if ( 0 <= alpha <= 1 ) _alpha = alpha;
+ if ( 0 <= alpha && alpha <= 1 ) _alpha = alpha;
else
throw CalciumException(CalciumTypes::CPRENA,LOC("Le paramètre alpha doit être compris entre [0,1]"));
}
void CalciumCouplingPolicy::setDeltaT(double deltaT ) {
if ( _dependencyType != CalciumTypes::TIME_DEPENDENCY )
throw CalciumException(CalciumTypes::CPITVR,LOC("Le paramètre deltaT sur un port qui n'est pas en dépendance temporelle n'a pas de sens"));
- if ( 0 <= deltaT <= 1 ) _deltaT = deltaT;
+ if ( 0 <= deltaT && deltaT <= 1 ) _deltaT = deltaT;
else
throw(CalciumException(CalciumTypes::CPRENA,LOC("Le paramètre deltaT doit être compris entre [0,1]")));
}
double CalciumCouplingPolicy::getDeltaT() const {return _deltaT;}
void CalciumCouplingPolicy::setInterpolationSchem (CalciumTypes::InterpolationSchem interpolationSchem) {
-#ifdef _DEBUG_
- std::cerr << "CalciumCouplingPolicy::setInterpolationSchem: " << interpolationSchem << std::endl;
-#endif
+ MESSAGE( "CalciumCouplingPolicy::setInterpolationSchem: " << interpolationSchem );
if ( _dependencyType != CalciumTypes::TIME_DEPENDENCY )
throw CalciumException(CalciumTypes::CPITVR,LOC("Le paramètre InterpolationSchem sur un port qui n'est pas en dépendance temporelle n'a pas de sens"));
_interpolationSchem=interpolationSchem;
#include "CalciumTypes.hxx"
#include "CalciumException.hxx"
+//#define MYDEBUG
+
class CalciumCouplingPolicy : public CouplingPolicy {
MapIterator it2=it1; ++it2;
size_t dataSize1 = DataManipulator::size(it1->second);
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- CalciumCouplingPolicy::BoundedDataIdProcessor : Taille de donnée dataId1 : " << dataSize1 << std::endl;
#endif
// Gérer dans calcium la limite de la taille du buffer donnée par
// l'utilisateur.
size_t dataSize2 = DataManipulator::size(it2->second);
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- CalciumCouplingPolicy::BoundedDataIdProcessor : Taille de donnée dataId2 : " << dataSize2 << std::endl;
#endif
DataId dataId1 = it1->first;
TimeType t2 = dataId2.first;
TimeType t1 = dataId1.first;
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- CalciumCouplingPolicy::BoundedDataIdProcessor : Valeur de t1 : " << t1 << std::endl;
std::cout << "-------- CalciumCouplingPolicy::BoundedDataIdProcessor : Valeur de t2 : " << t2 << std::endl;
#endif
TimeType t = dataId.first;
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- CalciumCouplingPolicy::BoundedDataIdProcessor : Valeur de t : " << t << std::endl;
#endif
TimeType timeDiff = t2-t1;
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- CalciumCouplingPolicy::BoundedDataIdProcessor : Valeur de timeDiff : " << timeDiff << std::endl;
#endif
TimeType coeff = (t2-t)/timeDiff;
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- CalciumCouplingPolicy::BoundedDataIdProcessor : Valeur de coeff : " << coeff << std::endl;
#endif
InnerType const * const InIt1 = DataManipulator::getPointer(it1->second);
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- CalciumCouplingPolicy::BoundedDataIdProcessor : Données à t1 : " << std::endl;
std::copy(InIt1,InIt1+dataSize1,std::ostream_iterator<InnerType>(std::cout," "));
std::cout << std::endl;
#endif
InnerType const * const InIt2 = DataManipulator::getPointer(it2->second);
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- CalciumCouplingPolicy::BoundedDataIdProcessor : Données à t2 : " << std::endl;
std::copy(InIt2,InIt2+dataSize2,std::ostream_iterator<InnerType>(std::cout," "));
std::cout << std::endl;
Type dataOut = DataManipulator::create(dataSize);
InnerType * const OutIt = DataManipulator::getPointer(dataOut);
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cerr << "-------- CalciumCouplingPolicy::BoundedDataIdProcessor : interpolationSchem : " << _couplingPolicy._interpolationSchem << std::endl;
std::cerr << "-------- CalciumCouplingPolicy::BoundedDataIdProcessor : alpha : " << _couplingPolicy._alpha << std::endl;
std::cerr << "-------- CalciumCouplingPolicy::BoundedDataIdProcessor : datecalschem : " << _couplingPolicy._dateCalSchem << std::endl;
// }
}
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- CalciumCouplingPolicy::BoundedDataIdProcessor : Données calculées à t : " << std::endl;
std::copy(OutIt,OutIt+dataSize,std::ostream_iterator<InnerType>(std::cout," "));
std::cout << std::endl;
AdjacentFunctor< key_type > af(expectedDataId);
if ( _dependencyType == CalciumTypes::TIME_DEPENDENCY )
{
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- time expected : " << expectedDataId.first << std::endl;
std::cout << "-------- time expected corrected : " << expectedDataId.first*(1.0-_deltaT) << std::endl;
#endif
typename AssocContainer::iterator current = prev;
while ( (current != storedDatas.end()) && !af(current->first) )
{
-#ifdef _DEBUG_
- std::cout << "------- stored time : " << current->first << std::endl;
+#ifdef MYDEBUG
+ std::cerr << "------- stored time : " << current->first << std::endl;
#endif
// if ( af(current->first) ) break;
prev = current++;
else
wDataIt1 = storedDatas.end();
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- isDataIdConvenient : isEqual : " << isEqual << " , isBounded " << isBounded << std::endl;
#endif
typedef typename Container::value_type value_type;
typedef typename Container::iterator iterator;
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- CalciumCouplingPolicy::eraseDataId, storedDatasSize : " << storedDatas.size() << std::endl;
#endif
" vient d'entraîner la suppression de la donnée à renvoyer")));
}
}
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- CalciumCouplingPolicy::eraseDataId, new storedDatasSize : " << storedDatas.size() << std::endl;
#endif
return;
typedef typename Container::iterator iterator;
// Pas de traitement particulier a effectuer
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- CalciumCouplingPolicy::DisconnectProcessor MARK1 ("<< _couplingPolicy._disconnectDirective<<") --------" << std::endl;
#endif
if ( (_couplingPolicy._disconnectDirective) == (CalciumTypes::UNDEFINED_DIRECTIVE) ) return false;
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- CalciumCouplingPolicy::DisconnectProcessor MARK2 --------" << std::endl;
#endif
if ( _couplingPolicy._disconnectDirective == CalciumTypes::CP_ARRET )
throw(CalciumException(CalciumTypes::CPINARRET,LOC(OSS()<< "La directive CP_ARRET"
<< " provoque l'interruption de toute lecture de données")));
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- CalciumCouplingPolicy::DisconnectProcessor MARK3 --------" << std::endl;
#endif
// qu'en mode itératif il ne soit pas plus grand que le plus grand DataId stocké auquel
// cas on doit renvoyer une expection car on n'est plus connecté et on ne pourra jamais
// fournir de données pour ce dataId.
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- CalciumCouplingPolicy::DisconnectProcessor MARK4 " << expectedDataId <<" --------" << std::endl;
#endif
// >= expectedDataId
iterator it1 = storedDatas.lower_bound(expectedDataId);
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- CalciumCouplingPolicy::DisconnectProcessor MARK5 " << std::endl;
for (iterator it=storedDatas.begin();it!=storedDatas.end();++it)
std::cout <<" "<<(*it).first ;
throw(CalciumException(CalciumTypes::CPNTNULL,LOC(OSS()<< "La directive CP_CONT"
<< " est active mais le dataId demandé est inférieur ou égal au dernier reçu.")));
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- CalciumCouplingPolicy::DisconnectProcessor MARK6 " << std::endl;
#endif
wDataIt1 = storedDatas.end();
--wDataIt1;
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- CalciumCouplingPolicy::DisconnectProcessor, CP_CONT : " << (*wDataIt1).first << std::endl;
#endif
static const bool value = true;
};
+//#define MYDEBUG
#include <boost/type_traits/remove_all_extents.hpp>
// calcium_uses_port* myCalciumUsesPort=
// dynamic_cast<calcium_uses_port*>(myUsesPort);
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cerr << "-------- CalciumInterface(ecp_fin) MARK 1 -|"<< *it <<"|----"<<
// typeid(myUsesPort).name() <<"-------------" <<
typeid(myCalciumUsesPort).name() <<"-------------" << std::endl;
myCalciumUsesPort->disconnect(provideLastGivenValue);
} catch ( const Superv_Component_i::BadCast & ex) {
-#ifdef _DEBUG_
- std::cerr << ex.what() << std::endl;
-#endif
+ MESSAGE(ex.what());
throw (CalciumException(CalciumTypes::CPTPVR,ex));
} catch ( const DSC_Exception & ex) {
-#ifdef _DEBUG_
- std::cerr << ex.what() << std::endl;
-#endif
+ MESSAGE(ex.what());
// Exception venant de SupervComponent :
// PortNotDefined(CPNMVR), PortNotConnected(CPLIEN)
// ou du port uses : Dsc_Exception
CorbaDataType corbaData;
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cerr << "-------- CalciumInterface(ecp_lecture) MARK 1 ------------------" << std::endl;
#endif
throw CalciumException(CalciumTypes::CPNMVR,
LOC("Le nom de la variable est <nul>"));
PortType * port;
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- CalciumInterface(lecture) MARK 2 --"<<typeid(port).name()<<"----------------" << std::endl;
T1 t1;
T2 t2;
try {
port = component.Superv_Component_i::get_port< PortType > (nomVar.c_str());
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- CalciumInterface(ecp_lecture) MARK 3 ------------------" << std::endl;
#endif
} catch ( const Superv_Component_i::PortNotDefined & ex) {
-#ifdef _DEBUG_
- std::cerr << ex.what() << std::endl;
-#endif
+ MESSAGE(ex.what());
throw (CalciumException(CalciumTypes::CPNMVR,ex));
} catch ( const Superv_Component_i::PortNotConnected & ex) {
-#ifdef _DEBUG_
- std::cerr << ex.what() << std::endl;;
-#endif
+ MESSAGE(ex.what());
throw (CalciumException(CalciumTypes::CPLIEN,ex));
// VERIFIER LES CAS DES CODES : CPINARRET, CPSTOPSEQ, CPCTVR, CPLIEN
} catch ( const Superv_Component_i::BadCast & ex) {
-#ifdef _DEBUG_
- std::cerr << ex.what() << std::endl;
-#endif
+ MESSAGE(ex.what());
throw (CalciumException(CalciumTypes::CPTPVR,ex));
}
if ( _dependencyType == CalciumTypes::TIME_DEPENDENCY ) {
corbaData = port->get(ti,tf, 0);
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- CalciumInterface(ecp_lecture) MARK 5 ------------------" << std::endl;
#endif
}
else if ( _dependencyType == CalciumTypes::ITERATION_DEPENDENCY ) {
corbaData = port->get(0, i);
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- CalciumInterface(ecp_lecture) MARK 6 ------------------" << std::endl;
#endif
} else {
// Lecture en séquence
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- CalciumInterface(ecp_lecture) MARK 7 ------------------" << std::endl;
#endif
corbaData = port->next(ti,i);
}
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- CalciumInterface(ecp_lecture) MARK 8 ------------------" << std::endl;
#endif
size_t corbaDataSize = DataManipulator::size(corbaData);
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- CalciumInterface(ecp_lecture) corbaDataSize : " << corbaDataSize << std::endl;
#endif
nRead = corbaDataSize;
// Si les types T1 et InnerType sont différents, il faudra effectuer tout de même une recopie
if (!IsSameType<T1,InnerType>::value) data = new T1[nRead];
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- CalciumInterface(ecp_lecture) MARK 9 ------------------" << std::endl;
#endif
// On essaye de faire du 0 copy si les types T1 et InnerType sont les mêmes.
// En utilisant le foncteur Copy2UserSpace, seule la spécialisation en adéquation
// avec la compatibilité des types sera compilée
Copy2UserSpace< IsSameType<T1,InnerType>::value, DataManipulator >::apply(data,corbaData,nRead);
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- CalciumInterface(ecp_lecture) MARK 10 ------------------" << std::endl;
#endif
// Attention : Seul CalciumCouplingPolicy via eraseDataId doit décider de supprimer ou non
// de désallouer un buffer intermédiaire ( types différents) ou de rendre la propriété
} else {
nRead = std::min < size_t > (corbaDataSize,bufferLength);
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- CalciumInterface(ecp_lecture) MARK 11 ------------------" << std::endl;
#endif
Copy2UserSpace<false, DataManipulator >::apply(data,corbaData,nRead);
//Déjà fait ci-dessus :
//DataManipulator::copy(corbaData,data,nRead);
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- CalciumInterface(ecp_lecture) MARK 12 ------------------" << std::endl;
#endif
}
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- CalciumInterface(ecp_lecture), Valeur de data : " << std::endl;
std::copy(data,data+nRead,std::ostream_iterator<T1>(std::cout," "));
std::cout << "Ptr :" << data << std::endl;
CalciumTypes::DependencyType _dependencyType=
static_cast<CalciumTypes::DependencyType>(dependencyType);
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cerr << "-------- CalciumInterface(ecriture) MARK 1 ------------------" << std::endl;
#endif
if ( nomVar.empty() ) throw CalciumException(CalciumTypes::CPNMVR,
LOC("Le nom de la variable est <nul>"));
UsesPortType * port;
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- CalciumInterface(ecriture) MARK 2 ---"<<typeid(port).name()<<"---------------" << std::endl;
T1 t1;
T2 t2;
try {
port = component.Superv_Component_i::get_port< UsesPortType > (nomVar.c_str());
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- CalciumInterface(ecriture) MARK 3 ------------------" << std::endl;
#endif
} catch ( const Superv_Component_i::PortNotDefined & ex) {
-#ifdef _DEBUG_
- std::cerr << ex.what() << std::endl;
-#endif
+ MESSAGE(ex.what());
throw (CalciumException(CalciumTypes::CPNMVR,ex));
} catch ( const Superv_Component_i::PortNotConnected & ex) {
-#ifdef _DEBUG_
- std::cerr << ex.what() << std::endl;;
-#endif
+ MESSAGE(ex.what());
throw (CalciumException(CalciumTypes::CPLIEN,ex));
// VERIFIER LES CAS DES CODES : CPINARRET, CPSTOPSEQ, CPCTVR, CPLIEN
} catch ( const Superv_Component_i::BadCast & ex) {
-#ifdef _DEBUG_
- std::cerr << ex.what() << std::endl;
-#endif
+ MESSAGE(ex.what());
throw (CalciumException(CalciumTypes::CPTPVR,ex));
}
CorbaDataType corbaData;
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- CalciumInterface(ecriture) MARK 4 ------------------" << std::endl;
#endif
// OLD : Il faut effectuer une copie dans le port provides.
// OLD : Cette copie est effectuée dans GenericPortUses::put
// OLD : en fonction de la collocalisation ou non.
+#ifdef MYDEBUG
T1_without_extent t1b;
InnerType t2b;
std::cout << "-------- CalciumInterface(ecriture) MARK 4b1 -----" << typeid(t1b).name() << "-------------" << std::endl;
std::cout << "-------- CalciumInterface(ecriture) MARK 4b2 -----" << typeid(t2b).name() << "-------------" << std::endl;
+#endif
Copy2CorbaSpace<IsSameType<T1_without_extent,InnerType>::value, DataManipulator >::apply(corbaData,_data,bufferLength);
}
//Le -1 peut être traité par le cst DataIdContainer et transformé en 0
//Etre obligé de mettre une étoile ds (*corbadata) va poser des pb pour les types <> seq
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- CalciumInterface(ecriture) MARK 5 ------------------" << std::endl;
#endif
}
{
throw (CalciumException(CalciumTypes::CPATAL,ex.what()));
}
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- CalciumInterface(ecriture) MARK 6 ------------------" << std::endl;
#endif
}
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- CalciumInterface(ecriture), Valeur de corbaData : " << std::endl;
for (int i = 0; i < corbaData->length(); ++i)
std::cout << "-------- CalciumInterface(ecriture), corbaData[" << i << "] = " << (*corbaData)[i] << std::endl;
// Supprime l'objet CORBA avec eventuellement les données qu'il contient (cas de la recopie)
delete corbaData;
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- CalciumInterface(ecriture) MARK 7 ------------------" << std::endl;
#endif
try { \
\
if (key == "StorageLevel" ) \
- {if ( ok=(value >>= sl) ) Port::setStorageLevel(sl);} \
+ {if ( ( ok=(value >>= sl) ) ) Port::setStorageLevel(sl);} \
else if (key == "Alpha" ) \
- {if ( ok=(value >>= alpha) ) Port::setAlpha(alpha);} \
+ {if ( ( ok=(value >>= alpha) ) ) Port::setAlpha(alpha);} \
else if (key == "DeltaT" ) \
- {if ( ok=(value >>= delta) ) Port::setDeltaT(delta);} \
+ {if ( ( ok=(value >>= delta) ) ) Port::setDeltaT(delta);} \
else if (key == "DependencyType" ) \
- {if ( ok=( value >>= dt) ) Port::setDependencyType(dependencyType[dt]);} \
+ {if ( ( ok=( value >>= dt) ) ) Port::setDependencyType(dependencyType[dt]);} \
else if (key == "DateCalSchem" ) \
- {if ( ok=(value >>= dcs) ) \
+ {if ( ( ok=(value >>= dcs) ) ) \
Port::setDateCalSchem(dateCalSchem[dcs]);} \
else if (key == "InterpolationSchem") \
- {if ( ok=(value >>= is) ) \
+ {if ( ( ok=(value >>= is) ) ) \
Port::setInterpolationSchem(interpolationSchem[is]);} \
else if (key == "ExtrapolationSchem") \
- {if ( ok=(value >>= es) ) \
+ {if ( ( ok=(value >>= es) ) ) \
Port::setExtrapolationSchem(extrapolationSchem[es]);} \
else \
throw Ports::NotDefined(); \
DEBTRACE( ex.what() ); \
return ex.getInfo(); \
} catch ( ... ) { \
- std::cerr << "Unexpected exception " << std::endl; \
+ DEBTRACE( "Unexpected exception ") ; \
return CalciumTypes::CPATAL; \
} \
if ( IsSameType< _porttype , cplx >::value ) { *nRead=_nRead/2; \
dependencyType, \
_t,i,nomvar,_bufferLength,*data); \
} catch ( const CalciumException & ex) { \
- std::cerr << ex.what() << std::endl; \
+ DEBTRACE( ex.what() ); \
return ex.getInfo(); \
} catch ( ... ) { \
- std::cerr << "Unexpected exception " << std::endl; \
+ DEBTRACE("Unexpected exception " ); \
return CalciumTypes::CPATAL; \
} \
fprintf(stderr,"End of ecp_ecriture_" #_name " : %s %ld %e\n",nomvar,i,_t); \
// Id : $Id$
//
#include "CalciumTypes2CorbaTypes.hxx"
+#include "utilities.h"
#include <iostream>
using namespace std;
map<CalciumTypes::DependencyType,
Ports::Calcium_Ports::DependencyType > &
table = ( map<CalciumTypes::DependencyType,
- Ports::Calcium_Ports::DependencyType > & ) *this ;
+ Ports::Calcium_Ports::DependencyType > & ) *this ;
-table[CalciumTypes::TIME_DEPENDENCY ] = Ports::Calcium_Ports::TIME_DEPENDENCY ;
-table[CalciumTypes::ITERATION_DEPENDENCY ] = Ports::Calcium_Ports::ITERATION_DEPENDENCY ;
-table[CalciumTypes::UNDEFINED_DEPENDENCY ] = Ports::Calcium_Ports::UNDEFINED_DEPENDENCY ;
+ table[CalciumTypes::TIME_DEPENDENCY ] = Ports::Calcium_Ports::TIME_DEPENDENCY ;
+ table[CalciumTypes::ITERATION_DEPENDENCY ] = Ports::Calcium_Ports::ITERATION_DEPENDENCY ;
+ table[CalciumTypes::UNDEFINED_DEPENDENCY ] = Ports::Calcium_Ports::UNDEFINED_DEPENDENCY ;
-#ifdef _DEBUG_
-std::cerr << "CORBA_DEPENDENCY_TYPE() : table["<<CalciumTypes::TIME_DEPENDENCY<<"] : "<<
- table[CalciumTypes::TIME_DEPENDENCY] << std::endl;
-std::cerr << "CORBA_DEPENDENCY_TYPE() : table["<<CalciumTypes::ITERATION_DEPENDENCY<<"] : "<<
- table[CalciumTypes::ITERATION_DEPENDENCY] << std::endl;
-std::cerr << "CORBA_DEPENDENCY_TYPE() : table["<<CalciumTypes::UNDEFINED_DEPENDENCY<<"] : "<<
- table[CalciumTypes::UNDEFINED_DEPENDENCY] << std::endl;
-#endif
+ MESSAGE("CORBA_DEPENDENCY_TYPE() : table["<<CalciumTypes::TIME_DEPENDENCY<<"] : "<< table[CalciumTypes::TIME_DEPENDENCY]);
+ MESSAGE("CORBA_DEPENDENCY_TYPE() : table["<<CalciumTypes::ITERATION_DEPENDENCY<<"] : "<< table[CalciumTypes::ITERATION_DEPENDENCY]);
+ MESSAGE("CORBA_DEPENDENCY_TYPE() : table["<<CalciumTypes::UNDEFINED_DEPENDENCY<<"] : "<< table[CalciumTypes::UNDEFINED_DEPENDENCY]);
}
map<CalciumTypes::DependencyType,
Ports::Calcium_Ports::DependencyType > &
table = (map<CalciumTypes::DependencyType,
- Ports::Calcium_Ports::DependencyType >& ) *this ;
+ Ports::Calcium_Ports::DependencyType >& ) *this ;
-#ifdef _DEBUG_
-std::cerr << "CORBA_DEPENDENCY_TYPE() : ::operator["<<c<<"]: " << table[c] << std::endl;
-#endif
+ MESSAGE("CORBA_DEPENDENCY_TYPE() : ::operator["<<c<<"]: " << table[c]);
assert( table.find( (CalciumTypes::DependencyType)c ) != table.end() ) ;
return table[ (CalciumTypes::DependencyType)c ] ;
#include <iostream>
#include "CalciumPortTraits.hxx"
+//#define MYDEBUG
+
template <bool zerocopy, typename DataManipulator>
struct Copy2CorbaSpace {
//ESSAI: typedef typename PortType::DataManipulator DataManipulator;
typedef typename DataManipulator::InnerType InnerType;
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cerr << "-------- Copy2CorbaSpace<true> MARK 1 ------------------" << std::endl;
#endif
// Crée le type corba à partir du data sans lui en donner la propriété.
// DataManipulator::create n'a pas le caractère const sur son paramètre data pour le
// cas de figure où la propriété de la donnée lui est donnée.
corbaData = DataManipulator::create(nRead,const_cast<T2 * > (&data),false);
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cerr << "-------- Copy2CorbaSpace<true> MARK 2 --(dataPtr : "
<< DataManipulator::getPointer(corbaData,false)<<")----------------" << std::endl;
#endif
corbaData = DataManipulator::create(nRead);
InnerType * dataPtr = DataManipulator::getPointer(corbaData,false);
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cerr << "-------- Copy2CorbaSpace<false> MARK 1 --(dataPtr : " <<
dataPtr<<")----------------" << std::endl;
#endif
// Attention : Pour les chaines ou tout autre object complexe il faut utiliser une recopie profonde !
std::copy(&data,&data+nRead,dataPtr);
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cerr << "-------- Copy2CorbaSpace<false> MARK 2 --(nRead: "<<nRead<<")-------------" << std::endl;
std::cerr << "-------- Copy2CorbaSpace<false> MARK 3 : " ;
#include <cstdio>
+//#define MYDEBUG
+
//Les demandes de copies vers l'espace utilisateur
//proviennent d'une procédure de lecture
typedef typename DataManipulator::InnerType InnerType;
-#ifdef _DEBUG_
+#ifdef MYDEBUG
InnerType * dataPtr = NULL;
// Affiche la valeur du pointeur de la structure corba
// et les pointeurs contenus le cas échéant
//std::copy(dataPtr,dataPtr+nRead,data);
DataManipulator::copy(corbaData,data,nRead);
-#ifdef _DEBUG_
+#ifdef MYDEBUG
tmpData = data;
std::cerr << "-------- Copy2UserSpace<false> MARK 1c --data("<<tmpData<<")[0.."<<
DataManipulator::size(corbaData) <<"] : ----------------" << std::endl;
// Id : $Id$
//
#include "CorbaTypes2CalciumTypes.hxx"
+#include "utilities.h"
#include <iostream>
using namespace std;
map<Ports::Calcium_Ports::DependencyType,
CalciumTypes::DependencyType > &
table = ( map<Ports::Calcium_Ports::DependencyType,
- CalciumTypes::DependencyType > & ) *this ;
+ CalciumTypes::DependencyType > & ) *this ;
-table[Ports::Calcium_Ports::TIME_DEPENDENCY ] = CalciumTypes::TIME_DEPENDENCY ;
-table[Ports::Calcium_Ports::ITERATION_DEPENDENCY ] = CalciumTypes::ITERATION_DEPENDENCY ;
-table[Ports::Calcium_Ports::UNDEFINED_DEPENDENCY ] = CalciumTypes::UNDEFINED_DEPENDENCY ;
+ table[Ports::Calcium_Ports::TIME_DEPENDENCY ] = CalciumTypes::TIME_DEPENDENCY ;
+ table[Ports::Calcium_Ports::ITERATION_DEPENDENCY ] = CalciumTypes::ITERATION_DEPENDENCY ;
+ table[Ports::Calcium_Ports::UNDEFINED_DEPENDENCY ] = CalciumTypes::UNDEFINED_DEPENDENCY ;
-
-#ifdef _DEBUG_
-std::cerr << "DEPENDENCY_TYPE() : table["<<Ports::Calcium_Ports::TIME_DEPENDENCY<<"] : "<<
- table[Ports::Calcium_Ports::TIME_DEPENDENCY] << std::endl;
-std::cerr << "DEPENDENCY_TYPE() : table["<<Ports::Calcium_Ports::ITERATION_DEPENDENCY<<"] : "<<
- table[Ports::Calcium_Ports::ITERATION_DEPENDENCY] << std::endl;
-std::cerr << "DEPENDENCY_TYPE() : table["<<Ports::Calcium_Ports::UNDEFINED_DEPENDENCY<<"] : "<<
- table[Ports::Calcium_Ports::UNDEFINED_DEPENDENCY] << std::endl;
-#endif
+ MESSAGE("DEPENDENCY_TYPE() : table["<<Ports::Calcium_Ports::TIME_DEPENDENCY<<"] : "<< table[Ports::Calcium_Ports::TIME_DEPENDENCY]);
+ MESSAGE("DEPENDENCY_TYPE() : table["<<Ports::Calcium_Ports::ITERATION_DEPENDENCY<<"] : "<< table[Ports::Calcium_Ports::ITERATION_DEPENDENCY]);
+ MESSAGE("DEPENDENCY_TYPE() : table["<<Ports::Calcium_Ports::UNDEFINED_DEPENDENCY<<"] : "<< table[Ports::Calcium_Ports::UNDEFINED_DEPENDENCY]);
}
CalciumTypes::DependencyType> &table = (map<Ports::Calcium_Ports::DependencyType,
CalciumTypes::DependencyType>&)*this ;
-#ifdef _DEBUG_
-std::cerr << "DEPENDENCY_TYPE() : ::operator["<<c<<"]: " << table[c] << std::endl;
-#endif
+ MESSAGE("DEPENDENCY_TYPE() : ::operator["<<c<<"]: " << table[c]);
assert( table.find( (Ports::Calcium_Ports::DependencyType)c ) != table.end() ) ;
return table[ (Ports::Calcium_Ports::DependencyType)c ] ;
#include <cstring>
#include <CORBA.h>
+//#define MYDEBUG
// Classes manipulation
// -------------------
// En non collocalisé on recrée une séquence avec le buffer de la première dont on
// a demandé la propriété.
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "----seq_u_manipulation::get_data(..)-- MARK 1 ------------------" << std::endl;
#endif
if ( data.release() ) {
// Crée une nouvelle sequence propriétaire des données du buffer (pas de recopie)
// Les données de la nouvelle séquence seront automatiquement désallouées
// par appel à la méthode freebuf dans le destructeur de la séquence (cf delete_data).
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "----seq_u_manipulation::get_data(..)-- MARK 1(0 copy) bis ------"<< p_data <<"------------" << std::endl;
#endif
return new seq_T (max, len, p_data, true);
}
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "----seq_u_manipulation::get_data(..)-- MARK 1(recopie) bis ------"<< &data <<"------------" << std::endl;
#endif
// Crée une nouvelle sequence propriétaire des données du buffer (avec recopie)
// Crée une nouvelle sequence propriétaire des données du buffer (généralement pas de recopie)
// Les données seront automatiquement désallouées par appel interne à la méthode freebuf
// lors de la destruction de l'objet par appel à delete_data.
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "----seq_u_manipulation::get_data(..)-- MARK 1bis Pas de Duplication -----------" << std::endl;
#endif
return new seq_T (len, p_data, true);
}
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "----seq_u_manipulation::get_data(..)-- MARK 1bis Duplication pour en devenir propriétaire -----------" << std::endl;
#endif
// Crée une nouvelle sequence propriétaire des données du buffer (avec recopie)
#include "Utils_CorbaException.hxx"
// SALOME C++ Exception
#include "Utils_SALOME_Exception.hxx"
+#include "utilities.h"
#include <iostream>
#include <map>
#include <algorithm>
#include <iterator>
+//#define MYDEBUG
+
// Classe GenericPort
// --------------------------------
//
GenericPort<DataManipulator, COUPLING_POLICY>::~GenericPort() {
typename DataTable::iterator it;
for (it=storedDatas.begin(); it!=storedDatas.end(); ++it) {
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cerr << "~GenericPort() : destruction de la donnnée associée au DataId :"<< (*it).first << std::endl;
#endif
DataManipulator::delete_data( (*it).second );
template < typename DataManipulator, typename COUPLING_POLICY> void
GenericPort<DataManipulator, COUPLING_POLICY>::wakeupWaiting()
{
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- wakeupWaiting ------------------" << std::endl;
#endif
storedDatas_mutex.lock();
if (waitingForAnyDataId || waitingForConvenientDataId) {
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- wakeupWaiting:signal --------" << std::endl;
std::cout << std::flush;
#endif
fflush(stdout);
fflush(stderr);
try {
-#ifdef _DEBUG_
+#ifdef MYDEBUG
// Affichage des donnees pour DEBUGging
std::cerr << "parametres emis: " << time << ", " << tag << std::endl;
DataManipulator::dump(dataParam);
bool expectedDataReceived = false;
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- Put : MARK 1 ------------------" << std::endl;
#endif
if ( dataIds.empty() ) return;
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- Put : MARK 1bis ------------------" << std::endl;
#endif
int nbOfIter = 0;
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- Put : MARK 2 ------ "<< (dataIdIt == dataIds.end()) << "------------" << std::endl;
std::cout << "-------- Put : MARK 2bis "<< (*dataIdIt) <<"------------------" << std::endl;
#endif
for (;dataIdIt != dataIds.end();++dataIdIt) {
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- Put : MARK 3 ------------------" << std::endl;
#endif
// Duplique l'instance de donnée pour les autres dataIds
if (nbOfIter > 0) data = DataManipulator::clone(data);
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- Put : MARK 3bis -----"<< dataIdIt.operator*() <<"------------" << std::endl;
#endif
DataId currentDataId=*dataIdIt;
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cerr << "processing dataId : "<< currentDataId << std::endl;
std::cout << "-------- Put : MARK 4 ------------------" << std::endl;
// <=> premier emplacement où l'on pourrait insérer notre DataId
// <=> en général équivaux à (*wDataIt).first >= currentDataId
typename DataTable::iterator wDataIt = storedDatas.lower_bound(currentDataId);
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- Put : MARK 5 ------------------" << std::endl;
#endif
// On n'a pas trouvé de dataId supérieur au notre ou
// on a trouvé une clé > à cet Id
if (wDataIt == storedDatas.end() || storedDatas.key_comp()(currentDataId,(*wDataIt).first) ) {
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- Put : MARK 6 ------------------" << std::endl;
#endif
// Ajoute la donnee dans la table
} else {
// Si on n'est pas en fin de liste et qu'il n'y a pas de relation d'ordre strict
// entre notre dataId et le DataId pointé c'est qu'ils sont identiques
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- Put : MARK 7 ------------------" << std::endl;
#endif
// Les données sont remplacées par les nouvelles valeurs
DataManipulator::delete_data (old_data);
}
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- Put : MARK 8 ------------------" << std::endl;
#endif
// Compte le nombre de dataIds à traiter
++nbOfIter;
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- Put : waitingForConvenientDataId : " << waitingForConvenientDataId <<"---" << std::endl;
std::cout << "-------- Put : waitingForAnyDataId : " << waitingForAnyDataId <<"---" << std::endl;
std::cout << "-------- Put : currentDataId : " << currentDataId <<"---" << std::endl;
( waitingForConvenientDataId &&
isDataIdConveniant(storedDatas, expectedDataId, dummy1, dummy2, dummy3) )
) {
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- Put : MARK 10 ------------------" << std::endl;
#endif
//Doit pouvoir réveiller le get ici (a vérifier)
}
if (expectedDataReceived) {
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- Put : MARK 11 ------------------" << std::endl;
#endif
// si waitingForAnyDataId était positionné, c'est forcément lui qui a activer
// Pb2 : également si deux attentes de DataIds même différents car on n'en stocke qu'un !
// Conclusion : Pour l'instant on ne gère pas un service multithreadé qui effectue
// des lectures simultanées sur le même port !
-#ifdef _DEBUG_
- std::cout << "-------- Put : new datas available ------------------" << std::endl;
-#endif
+ MESSAGE("-------- Put : new datas available ------------------");
fflush(stdout);fflush(stderr);
cond_instance.signal();
}
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- Put : MARK 12 ------------------" << std::endl;
#endif
// Deverouille l'acces a la table : On peut remonter l'appel au dessus de expected...
storedDatas_mutex.unlock();
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- Put : MARK 13 ------------------" << std::endl;
#endif
fflush(stdout);
bool isEqual, isBounded;
typedef typename DataManipulator::InnerType InnerType;
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- Get : MARK 1 ------------------" << std::endl;
#endif
expectedDataId = DataId(time,tag);
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- Get : MARK 2 ------------------" << std::endl;
#endif
// - l'itérateur wDataIt1 est tel que wDataIt1->first < wdataId < (wDataIt1+1)->first
// Méthode provenant de la COUPLING_POLICY
isDataIdConveniant(storedDatas,expectedDataId,isEqual,isBounded,wDataIt1);
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- Get : MARK 3 ------------------" << std::endl;
#endif
// L'ordre des différents tests est important
if ( isEqual ) {
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- Get : MARK 4 ------------------" << std::endl;
#endif
// La propriété de la données N'EST PAS transmise à l'utilisateur en mode CALCIUM.
// Du coup interaction potentielle entre le 0 copy et gestion de l'historique
dataToTransmit = (*wDataIt1).second;
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- Get : MARK 5 ------------------" << std::endl;
std::cout << "-------- Get : Données trouvées à t : " << std::endl;
typename DataManipulator::InnerType const * const InIt1 = DataManipulator::getPointer(dataToTransmit);
// Méthode provenant de la COUPLING_POLICY
typename COUPLING_POLICY::template EraseDataIdProcessor<DataManipulator> processEraseDataId(*this);
processEraseDataId.apply(storedDatas,wDataIt1);
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- Get : MARK 6 ------------------" << std::endl;
#endif
break;
}
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- Get : MARK 7 ------------------" << std::endl;
#endif
// Cependant comme les données sont censées être produites
// par ordre croissant de DataId, de nouvelles données ne devrait pas améliorer
// l'interpolation.
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- Get : MARK 8 ------------------" << std::endl;
#endif
// A déplacer en paramètre de la méthode précédente ? ou déléguer ce choix au mode de couplage ?
storedDatas[expectedDataId]=dataToTransmit;
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- Get : Données calculées à t : " << std::endl;
typename DataManipulator::InnerType const * const InIt1 = DataManipulator::getPointer(dataToTransmit);
size_t N = DataManipulator::size(dataToTransmit);
// Réception bloquante sur le dataId demandé
// Si l'instance de donnée n'est pas trouvee
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- Get : MARK 10 ------------------" << std::endl;
#endif
//Positionné à faux dans la méthode put
waitingForConvenientDataId = true;
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- Get : MARK 11 ------------------" << std::endl;
// Ici on attend que la méthode put recoive la donnée
fflush(stdout);fflush(stderr);
cond_instance.wait();
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- Get : MARK 12 ------------------" << std::endl;
#endif
}
// Deverouille l'acces a la table
storedDatas_mutex.unlock();
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- Get : MARK 13 ------------------" << std::endl;
#endif
try {
storedDatas_mutex.lock();// Gérer les Exceptions ds le corps de la méthode
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- Next : MARK 1 ---lastDataIdSet ("<<lastDataIdSet<<")---------------" << std::endl;
#endif
waitingForAnyDataId = false; break;
}
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- Next : MARK 2 ------------------" << std::endl;
#endif
//Positionné à faux dans la méthode put
waitingForAnyDataId = true;
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- Next : MARK 3 ------------------" << std::endl;
// Ici on attend que la méthode put recoive la donnée
std::cout << "-------- Next : waiting datas ------------------" << std::endl;
cond_instance.wait();
if (lastDataIdSet) {
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- Next : MARK 4 ------------------" << std::endl;
#endif
wDataIt1 = storedDatas.upper_bound(lastDataId);
} else {
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- Next : MARK 5 ------------------" << std::endl;
#endif
lastDataIdSet = true;
}
}
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- Next : MARK 6 ------------------" << std::endl;
#endif
tag = getTag ( (*wDataIt1).first );
dataToTransmit = (*wDataIt1).second;
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- Next : MARK 7 ------------------" << std::endl;
#endif
lastDataId = (*wDataIt1).first;
typename COUPLING_POLICY::template EraseDataIdProcessor<DataManipulator> processEraseDataId(*this);
processEraseDataId.apply(storedDatas, wDataIt1);
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- Next : MARK 8 ------------------" << std::endl;
#endif
} catch (...) {
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- Next : MARK 8bis ------------------" << std::endl;
#endif
waitingForAnyDataId = false;
}
storedDatas_mutex.unlock();
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "-------- Next : MARK 9 ------------------" << std::endl;
#endif
CorbaPortTypeVar port = CorbaPortType::_narrow((*_my_ports)[i]);
//if (i) { PB1
//OLD : copyOfData = DataManipulator::clone(data);
-#ifdef _DEBUG_
- std::cout << "-------- GenericUsesPort::put -------- " << std::endl;
-#endif
+ MESSAGE("-------- GenericUsesPort::put -------- " );
//} PB1
try {
port->put(data,time,tag);
// OLD : port->put(*copyOfData,time,tag);
} catch(const CORBA::SystemException& ex) {
//OLD : DataManipulator::delete_data(copyOfData);
- throw DSC_Exception(LOC(OSS() << "Impossible d'invoquer la méthode put sur le port n°"
+ throw DSC_Exception(LOC(OSS() << "Can't invoke put method on port number "
<< i << "( i>= 0)"));
}
{
if (_my_ports) delete _my_ports;
-#ifdef _DEBUG_
- std::cerr << "GenericUsesPort::uses_port_changed" << std::endl;
-#endif
+ MESSAGE("GenericUsesPort::uses_port_changed");
_my_ports = new_uses_port;
}
bool notif) :
Engines_DSC_i(orb, poa, contId, instanceName, interfaceName)
{
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cerr << "--Superv_Component_i : MARK 1 ---- " << instanceName << "----" << std::endl;
#endif
}
bool regist) :
Engines_DSC_i(orb, poa, container, instanceName, interfaceName,notif,regist)
{
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cerr << "--Superv_Component_i : MARK 1 ---- " << instanceName << "----" << std::endl;
#endif
}
add_port(port, port_name);
}
else if (s_port_type == "uses") {
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cerr << "---- Superv_Component_i::add_port : MARK 1 ---- " << std::endl;
#endif
uses_port * port = create_uses_data_port(port_fab_type);
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cerr << "---- Superv_Component_i::add_port : MARK 2 ---- " << std::endl;
#endif
add_port(port, port_name);
#include "DSC_Exception.hxx"
#include <vector>
+//#define MYDEBUG
/*! \class Superv_Component_i
* \brief This class implements DSC_User component.
assert(port_name);
SpecificPortType * retPort;
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "---- Superv_Component_i::add_port : Mark 0 ---- " << port_name << "----" << std::endl;
#endif
else if (s_port_type == "uses") {
uses_port * port = create_uses_data_port(port_fab_type);
add_port(port, port_name);
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "---- Superv_Component_i::add_port : Mark 1 ---- " << port << "----" << std::endl;
std::cout << "---- Superv_Component_i::add_port : Mark 1 ---- get_repository_id()" << port->get_repository_id() << std::endl;
#endif
retPort = dynamic_cast<SpecificPortType *>(port);
-#ifdef _DEBUG_
+#ifdef MYDEBUG
std::cout << "---- Superv_Component_i::add_port : Mark 2 ---- " << retPort << "----" << std::endl;
#endif
if ( retPort == NULL ) { delete port;
