#define DSC_BASIC_EXPORT
#endif
-#endif
\ No newline at end of file
+#endif
+
// Suppose que les valeurs passées en paramètres sont triées par ordre croissant
bool operator()(const T &v1) {
+#ifdef _DEBUG_
std::cout << "AdjacentFunctor: " << _minValue << _maxValue << std::endl;
std::cout << "AdjacentFunctor: " << _min << _max << std::endl;
+#endif
if ( v1 <= _minValue && v1 >= _maxValue)
{
_equal= true;
+#ifdef _DEBUG_
std::cout << "AdjacentFunctor: _equal : " << v1 << std::endl;
+#endif
return true;
}
if ( v1 < _minValue )
{
_min=v1;_minFound=true;
+#ifdef _DEBUG_
std::cout << "AdjacentFunctor: _minFound : " <<_min << std::endl;
+#endif
}
else if ( v1 > _maxValue )
{
_max=v1;_maxFound=true;
+#ifdef _DEBUG_
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_
std::cout << "_minFound : " <<_minFound << ", _maxFound " << _maxFound << std::endl;
+#endif
if (_minFound && _maxFound ) { min=_min; max=_max; return true; }
return false;
}
fflush(stderr); \
fprintf(stderr,"Beginning of CPExx: %s %d %f\n",nomvar,i,t); \
if ( (data == NULL) || (nbelem < 1) ) return CPNTNULL; \
- printf("cp_name : Valeur de nomvar %s\n",nomvar); \
\
InfoType info = ecp_ecriture_##_typeName (component, mode, &t, i, \
nomvar, nbelem, \
MapIterator it2=it1; ++it2;
size_t dataSize1 = DataManipulator::size(it1->second);
+#ifdef _DEBUG_
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_
std::cout << "-------- CalciumCouplingPolicy::BoundedDataIdProcessor : Taille de donnée dataId2 : " << dataSize2 << std::endl;
+#endif
size_t dataSize = std::min< size_t >( dataSize1, dataSize2 );
DataId dataId2 = it2->first;
DataId dataId1 = it1->first;
TimeType t2 = dataId2.first;
TimeType t1 = dataId1.first;
+#ifdef _DEBUG_
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_
std::cout << "-------- CalciumCouplingPolicy::BoundedDataIdProcessor : Valeur de t : " << t << std::endl;
+#endif
TimeType timeDiff = t2-t1;
+#ifdef _DEBUG_
std::cout << "-------- CalciumCouplingPolicy::BoundedDataIdProcessor : Valeur de timeDiff : " << timeDiff << std::endl;
+#endif
TimeType coeff = (t2-t)/timeDiff;
+#ifdef _DEBUG_
std::cout << "-------- CalciumCouplingPolicy::BoundedDataIdProcessor : Valeur de coeff : " << coeff << std::endl;
+#endif
InnerType const * const InIt1 = DataManipulator::getPointer(it1->second);
+#ifdef _DEBUG_
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_
std::cout << "-------- CalciumCouplingPolicy::BoundedDataIdProcessor : Données à t2 : " << std::endl;
std::copy(InIt2,InIt2+dataSize2,std::ostream_iterator<InnerType>(std::cout," "));
std::cout << std::endl;
+#endif
Type dataOut = DataManipulator::create(dataSize);
InnerType * const OutIt = DataManipulator::getPointer(dataOut);
// }
}
+#ifdef _DEBUG_
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;
+#endif
data = dataOut;
}
AdjacentFunctor< key_type > af(expectedDataId);
if ( _dependencyType == CalciumTypes::TIME_DEPENDENCY )
{
+#ifdef _DEBUG_
std::cout << "-------- time expected : " << expectedDataId.first << std::endl;
std::cout << "-------- time expected corrected : " << expectedDataId.first*(1.0-_deltaT) << std::endl;
+#endif
af.setMaxValue(key_type(expectedDataId.first*(1.0-_deltaT),0));
}
isBounded = false;
typename AssocContainer::iterator current = prev;
while ( (current != storedDatas.end()) && !af(current->first) )
{
+#ifdef _DEBUG_
std::cout << "------- stored time : " << current->first << std::endl;
+#endif
// if ( af(current->first) ) break;
prev = current++;
}
else
wDataIt1 = storedDatas.end();
+#ifdef _DEBUG_
std::cout << "-------- isDataIdConvenient : isEqual : " << isEqual << " , isBounded " << isBounded << std::endl;
+#endif
return isEqual || isBounded;
}
typedef typename Container::value_type value_type;
typedef typename Container::iterator iterator;
+#ifdef _DEBUG_
std::cout << "-------- CalciumCouplingPolicy::eraseDataId, storedDatasSize : " << storedDatas.size() << std::endl;
+#endif
if ( _couplingPolicy._storageLevel == CalciumTypes::UNLIMITED_STORAGE_LEVEL ) return;
if (s > 0 ) {
size_t dist=distance(storedDatas.begin(),wDataIt1);
for (int i=0; i<s; ++i) {
- DataManipulator::delete_data((*storedDatas.begin()).second);
- storedDatas.erase(storedDatas.begin());
+ //no bug if removed : DataManipulator::delete_data((*storedDatas.begin()).second);
+ DataManipulator::delete_data((*storedDatas.begin()).second);
+ storedDatas.erase(storedDatas.begin());
}
// Si l'itérateur pointait sur une valeur que l'on vient de supprimer
if (dist < s ) {
" vient d'entraîner la suppression de la donnée à renvoyer")));
}
}
+#ifdef _DEBUG_
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_
std::cout << "-------- CalciumCouplingPolicy::DisconnectProcessor MARK1 ("<< _couplingPolicy._disconnectDirective<<") --------" << std::endl;
+#endif
if ( (_couplingPolicy._disconnectDirective) == (CalciumTypes::UNDEFINED_DIRECTIVE) ) return false;
+#ifdef _DEBUG_
std::cout << "-------- CalciumCouplingPolicy::DisconnectProcessor MARK2 --------" << std::endl;
+#endif
// TODO : Ds GenericPort::next il faut convertir en CPSTOPSEQ
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_
std::cout << "-------- CalciumCouplingPolicy::DisconnectProcessor MARK3 --------" << std::endl;
+#endif
// S'il n'y a plus de données indique que l'on a pas pu effectuer de traitement
// 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_
std::cout << "-------- CalciumCouplingPolicy::DisconnectProcessor MARK4 " << expectedDataId <<" --------" << std::endl;
+#endif
// >= expectedDataId
iterator it1 = storedDatas.lower_bound(expectedDataId);
+#ifdef _DEBUG_
std::cout << "-------- CalciumCouplingPolicy::DisconnectProcessor MARK5 " << std::endl;
for (iterator it=storedDatas.begin();it!=storedDatas.end();++it)
std::cout <<" "<<(*it).first ;
std::cout <<std::endl;
+#endif
// TODO : Il faut en fait renvoyer le plus proche cf IT ou DT
if (it1 == storedDatas.end())
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_
std::cout << "-------- CalciumCouplingPolicy::DisconnectProcessor MARK6 " << std::endl;
+#endif
wDataIt1 = storedDatas.end();
--wDataIt1;
+#ifdef _DEBUG_
std::cout << "-------- CalciumCouplingPolicy::DisconnectProcessor, CP_CONT : " << (*wDataIt1).first << std::endl;
+#endif
return true;
}
// calcium_uses_port* myCalciumUsesPort=
// dynamic_cast<calcium_uses_port*>(myUsesPort);
+#ifdef _DEBUG_
std::cerr << "-------- CalciumInterface(ecp_fin) MARK 1 -|"<< *it <<"|----"<<
// typeid(myUsesPort).name() <<"-------------" <<
typeid(myCalciumUsesPort).name() <<"-------------" << std::endl;
+#endif
// if ( !myCalciumUsesPort )
// throw Superv_Component_i::BadCast(LOC(OSS()<<"Impossible de convertir le port "
myCalciumUsesPort->disconnect(provideLastGivenValue);
} catch ( const Superv_Component_i::BadCast & ex) {
+#ifdef _DEBUG_
std::cerr << ex.what() << std::endl;
+#endif
throw (CalciumException(CalciumTypes::CPTPVR,ex));
} catch ( const DSC_Exception & ex) {
+#ifdef _DEBUG_
std::cerr << ex.what() << std::endl;
+#endif
// Exception venant de SupervComponent :
// PortNotDefined(CPNMVR), PortNotConnected(CPLIEN)
// ou du port uses : Dsc_Exception
CorbaDataType corbaData;
long ilong;
+#ifdef _DEBUG_
std::cerr << "-------- CalciumInterface(ecp_lecture) MARK 1 ------------------" << std::endl;
+#endif
if (nomVar.empty())
throw CalciumException(CalciumTypes::CPNMVR,
LOC("Le nom de la variable est <nul>"));
PortType * port;
+#ifdef _DEBUG_
std::cout << "-------- CalciumInterface(ecp_lecture) MARK 2 ------------------" << std::endl;
+#endif
try {
port = component.Superv_Component_i::get_port< PortType > (nomVar.c_str());
+#ifdef _DEBUG_
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
throw (CalciumException(CalciumTypes::CPNMVR,ex));
} catch ( const Superv_Component_i::PortNotConnected & ex) {
+#ifdef _DEBUG_
std::cerr << ex.what() << std::endl;;
+#endif
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
throw (CalciumException(CalciumTypes::CPTPVR,ex));
}
if ( dependencyType == CalciumTypes::TIME_DEPENDENCY ) {
corbaData = port->get(ti,tf, 0);
+#ifdef _DEBUG_
std::cout << "-------- CalciumInterface(ecp_lecture) MARK 5 ------------------" << std::endl;
+#endif
}
else if ( dependencyType == CalciumTypes::ITERATION_DEPENDENCY ) {
corbaData = port->get(0, i);
+#ifdef _DEBUG_
std::cout << "-------- CalciumInterface(ecp_lecture) MARK 6 ------------------" << std::endl;
+#endif
} else {
// Lecture en séquence
+#ifdef _DEBUG_
std::cout << "-------- CalciumInterface(ecp_lecture) MARK 7 ------------------" << std::endl;
+#endif
corbaData = port->next(ti,i);
}
+#ifdef _DEBUG_
std::cout << "-------- CalciumInterface(ecp_lecture) MARK 8 ------------------" << std::endl;
+#endif
size_t corbaDataSize = DataManipulator::size(corbaData);
+#ifdef _DEBUG_
std::cout << "-------- CalciumInterface(ecp_lecture) corbaDataSize : " << corbaDataSize << std::endl;
+#endif
// Vérifie si l'utilisateur demande du 0 copie
if ( data == NULL ) {
nRead = corbaDataSize;
// Si les types T 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_
std::cout << "-------- CalciumInterface(ecp_lecture) MARK 9 ------------------" << std::endl;
+#endif
// On essaye de faire du 0 copy si les types T et InnerType sont les mêmes
Copy2UserSpace< IsSameType<T1,InnerType>::value >::apply(data,corbaData,nRead);
+#ifdef _DEBUG_
std::cout << "-------- CalciumInterface(ecp_lecture) MARK 10 ------------------" << std::endl;
+#endif
// Attention : Seul CalciumCouplingPolicy via eraseDataId doit décider de supprimer ou non
// la donnée corba associée à un DataId ! Ne pas effectuer la desallocation suivante :
// old : Dans les deux cas la structure CORBA n'est plus utile
// DataManipulator::delete_data(corbaData);
} else {
nRead = std::min < size_t > (corbaDataSize,bufferLength);
+#ifdef _DEBUG_
std::cout << "-------- CalciumInterface(ecp_lecture) MARK 11 ------------------" << std::endl;
+#endif
Copy2UserSpace<false>::apply(data,corbaData,nRead);
+#ifdef _DEBUG_
std::cout << "-------- CalciumInterface(ecp_lecture) MARK 12 ------------------" << std::endl;
+#endif
// Attention : Seul CalciumCouplingPolicy via eraseDataId doit décider de supprimer ou non
// la donnée corba associée à un DataId ! Ne pas effectuer la desallocation suivante :
// DataManipulator::delete_data(corbaData);
}
+#ifdef _DEBUG_
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;
std::cout << "-------- CalciumInterface(ecp_lecture) MARK 13 ------------------" << std::endl;
+#endif
return;
typedef typename DataManipulator::Type CorbaDataType; // Attention != T1
typedef typename DataManipulator::InnerType InnerType;
+#ifdef _DEBUG_
std::cerr << "-------- CalciumInterface(ecriture) MARK 1 ------------------" << std::endl;
+#endif
if ( nomVar.empty() ) throw CalciumException(CalciumTypes::CPNMVR,
LOC("Le nom de la variable est <nul>"));
PortType * port;
+#ifdef _DEBUG_
std::cout << "-------- CalciumInterface(ecriture) MARK 2 ------------------" << std::endl;
+#endif
try {
port = component.Superv_Component_i::get_port< PortType > (nomVar.c_str());
+#ifdef _DEBUG_
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
throw (CalciumException(CalciumTypes::CPNMVR,ex));
} catch ( const Superv_Component_i::PortNotConnected & ex) {
+#ifdef _DEBUG_
std::cerr << ex.what() << std::endl;;
+#endif
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
throw (CalciumException(CalciumTypes::CPTPVR,ex));
}
LOC(OSS()<<"Le buffer a envoyer est de taille nulle "));
+#ifdef _DEBUG_
std::cout << "-------- CalciumInterface(ecriture) MARK 7 ------------------" << std::endl;
+#endif
CorbaDataType corbaData;
port->put(*corbaData,t, -1);
//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_
std::cout << "-------- CalciumInterface(ecriture) MARK 5 ------------------" << std::endl;
+#endif
}
else if ( dependencyType == CalciumTypes::ITERATION_DEPENDENCY ) {
port->put(*corbaData,-1, i);
+#ifdef _DEBUG_
std::cout << "-------- CalciumInterface(ecriture) MARK 6 ------------------" << std::endl;
+#endif
}
+#ifdef _DEBUG_
std::cout << "-------- CalciumInterface(ecriture), Valeur de corbaData : " << std::endl;
for (int i = 0; i < corbaData->length(); ++i)
cout << "-------- CalciumInterface(ecriture), corbaData[" << i << "] = " << (*corbaData)[i] << endl;
+#endif
// if ( !IsSameType<T1,InnerType>::value ) delete corbaData;
// Supprime l'objet CORBA avec eventuellement les données qu'il contient (case de la recopie)
delete corbaData;
+#ifdef _DEBUG_
std::cout << "-------- CalciumInterface(ecriture) MARK 7 ------------------" << std::endl;
+#endif
return;
}
CalciumInterface::ecp_fin( *_component,
provideLastGivenValue);
} catch ( const CalciumException & ex) { //tester l'arrêt par exception
+#ifdef _DEBUG_
std::cerr << ex.what() << std::endl;
+#endif
return ex.getInfo();
}
return CalciumTypes::CPOK;
};
+#ifdef _DEBUG_
+#define DEBTRACE(msg) {std::cerr<<std::flush<<__FILE__<<" ["<<__LINE__<<"] : "<<msg<<std::endl<<std::flush;}
+#else
+#define DEBTRACE(msg)
+#endif
+
#define CALCIUM_C2CPP_INTERFACE_(_name,_type,_qual) \
extern "C" CalciumTypes::InfoType ecp_lecture_##_name (void * component, int dependencyType, \
static_cast<CalciumTypes::DependencyType>(dependencyType); \
\
if ( IsSameType< _name , cplx >::value ) _bufferLength*=2; \
- std::cout << "-------- CalciumInterface(lecture Inter Part) MARK 1 ------------------" << std::endl; \
+ DEBTRACE( "-------- CalciumInterface(lecture Inter Part) MARK 1 ------------------" ) \
try { \
CalciumInterface::ecp_lecture< _type, _name >( *_component, \
_dependencyType, \
nomvar, \
_bufferLength, _nRead, *data); \
} catch ( const CalciumException & ex) { \
- std::cout << "-------- CalciumInterface(lecture Inter Part) MARK 1b ------------------" << std::endl; \
- std::cerr << ex.what() << std::endl; \
- std::cout << "-------- CalciumInterface(lecture Inter Part) MARK 1ter ------------------" << std::endl; \
+ DEBTRACE( "-------- CalciumInterface(lecture Inter Part) MARK 1b ------------------" ) \
+ DEBTRACE( ex.what() ) \
+ DEBTRACE( "-------- CalciumInterface(lecture Inter Part) MARK 1ter ------------------" ) \
return ex.getInfo(); \
} \
if ( IsSameType< _name , cplx >::value ) { *nRead=_nRead/2; \
- std::cout << "-------- CalciumInterface(lecture Inter Part) IsSameType cplx -------------" << std::endl; \
- std::cout << "-------- CalciumInterface(lecture Inter Part) _nRead : " << _nRead << std::endl; \
- std::cout << "-------- CalciumInterface(lecture Inter Part) *nRead : " << *nRead << std::endl; \
+ DEBTRACE( "-------- CalciumInterface(lecture Inter Part) IsSameType cplx -------------" ) \
+ DEBTRACE( "-------- CalciumInterface(lecture Inter Part) _nRead : " << _nRead ) \
+ DEBTRACE( "-------- CalciumInterface(lecture Inter Part) *nRead : " << *nRead ) \
} else *nRead = _nRead; \
if (_dependencyType == CalciumTypes::CP_SEQUENTIEL ) \
*ti=(CalTimeType< _type _qual >::TimeType)(_ti); \
- std::cout << "-------- CalciumInterface(lecture Inter Part), Data Ptr :" << *data << std::endl; \
+ DEBTRACE( "-------- CalciumInterface(lecture Inter Part), Data Ptr :" << *data ) \
+ /* \
for (int i=0; i<_nRead;++i) \
printf("-------- CalciumInterface(lecture Inter Part), Valeur de data (typage entier) data[%d] : %d \n",i,(*data)[i]); \
- std::cout << "-------- CalciumInterface(lecture Inter Part), Data Ptr :" << *data << std::endl; \
+ */ \
+ DEBTRACE( "-------- CalciumInterface(lecture Inter Part), Data Ptr :" << *data ) \
return CalciumTypes::CPOK; \
}; \
extern "C" void ecp_lecture_##_name##_free ( _type _qual * data) { \
double _t=*t; \
size_t _bufferLength=bufferLength; \
if ( IsSameType< _name , cplx >::value ) _bufferLength=_bufferLength*2; \
- std::cout << "-------- CalciumInterface(ecriture Inter Part) MARK 1 ------------------" << std::endl; \
+ DEBTRACE( "-------- CalciumInterface(ecriture Inter Part) MARK 1 ------------------" ) \
try { \
- printf("-------- CalciumInterface(ecriture Inter Part), cp_name : Nom de la var. de type %s : %s\n",#_type,nomvar); \
+ /*printf("-------- CalciumInterface(ecriture Inter Part), cp_name : Nom de la var. de type %s : %s\n",#_type,nomvar);*/ \
std::string essai(nomvar); \
- std::cout << "----------->-" << nomvar << std::endl; \
+ DEBTRACE( "----------->-" << nomvar ) \
CalciumInterface::ecp_ecriture< _type, _name >( *_component, \
static_cast<CalciumTypes::DependencyType>(dependencyType), \
_t,i,nomvar,_bufferLength,*data); \
} catch ( const CalciumException & ex) { \
- std::cerr << ex.what() << std::endl; \
+ DEBTRACE( ex.what() ) \
return ex.getInfo(); \
} \
- std::cout << "-------- CalciumInterface(ecriture Inter Part), Valeur de data : " << std::endl; \
- std::cout << "-------- CalciumInterface(ecriture Inter Part), Ptr(1) :" << data << std::endl; \
+ DEBTRACE( "-------- CalciumInterface(ecriture Inter Part), Valeur de data : " ) \
+ DEBTRACE( "-------- CalciumInterface(ecriture Inter Part), Ptr(1) :" << data ) \
+ /* \
for (int i=0; i<_bufferLength;++i) \
printf("-------- CalciumInterface(ecriture Inter Part), Valeur de data (typage entier) data[%d] : %d \n",i,data[i]); \
- std::cout << "-------- CalciumInterface(ecriture Inter Part), Ptr(2) :" << data << std::endl; \
+ */ \
+ DEBTRACE( "-------- CalciumInterface(ecriture Inter Part), Ptr(2) :" << data ) \
return CalciumTypes::CPOK; \
}; \
table[CalciumTypes::UNDEFINED_DEPENDENCY ] = Ports::Calcium_Ports::UNDEFINED_DEPENDENCY ;
+#ifdef _DEBUG_
std::cout << "CORBA_DEPENDENCY_TYPE() : table["<<CalciumTypes::TIME_DEPENDENCY<<"] : "<<
table[CalciumTypes::TIME_DEPENDENCY] << std::endl;
std::cout << "CORBA_DEPENDENCY_TYPE() : table["<<CalciumTypes::ITERATION_DEPENDENCY<<"] : "<<
table[CalciumTypes::ITERATION_DEPENDENCY] << std::endl;
std::cout << "CORBA_DEPENDENCY_TYPE() : table["<<CalciumTypes::UNDEFINED_DEPENDENCY<<"] : "<<
table[CalciumTypes::UNDEFINED_DEPENDENCY] << std::endl;
+#endif
}
table = (map<CalciumTypes::DependencyType,
Ports::Calcium_Ports::DependencyType >& ) *this ;
+#ifdef _DEBUG_
std::cout << "CORBA_DEPENDENCY_TYPE() : ::operator["<<c<<"]: " << table[c] << std::endl;
+#endif
assert( table.find( (CalciumTypes::DependencyType)c ) != table.end() ) ;
return table[ (CalciumTypes::DependencyType)c ] ;
typedef typename PortType::DataManipulator DataManipulator;
typedef typename DataManipulator::InnerType InnerType;
+#ifdef _DEBUG_
std::cerr << "-------- Copy2CorbaSpace<true> MARK 1 ------------------" << std::endl;
+#endif
// Crée le type corba à partir du data sans lui en donner la propriété
corbaData = DataManipulator::create(nRead,&data,false);
+#ifdef _DEBUG_
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_
std::cerr << "-------- Copy2CorbaSpace<false> MARK 1 --(dataPtr : " <<
dataPtr<<")----------------" << std::endl;
+#endif
std::copy(&data,&data+nRead,dataPtr);
+#ifdef _DEBUG_
std::cerr << "-------- Copy2CorbaSpace<false> MARK 2 --(nRead: "<<nRead<<")-------------" << std::endl;
std::cerr << "-------- Copy2CorbaSpace<false> MARK 3 : " ;
for (int i=0; i<nRead; ++i)
std::cerr << (*corbaData)[i] << " ";
std::cout << std::endl;
+#endif
}
};
// Recopie des données dans le buffer allouée la méthode appelante
// dans le cas d'une demande utilisateur 0 copie mais sur
// des types utilisateurs et CORBA incompatibles.
+#ifdef _DEBUG_
std::cerr << "-------- Copy2UserSpace<false> MARK 1 --(dataPtr : " <<dataPtr<<")----------------" << std::endl;
+#endif
std::copy(dataPtr,dataPtr+nRead,data);
+#ifdef _DEBUG_
std::cerr << "-------- Copy2UserSpace<false> MARK 2 --(nRead: "<<nRead<<")-------------" << std::endl;
std::cerr << "-------- Copy2UserSpace<false> MARK 3 --(data : " <<data<<") :";
std::copy(data,data+nRead,std::ostream_iterator<T1>(std::cout," "));
std::cout << std::endl;
+#endif
}
};
table[Ports::Calcium_Ports::UNDEFINED_DEPENDENCY ] = CalciumTypes::UNDEFINED_DEPENDENCY ;
+#ifdef _DEBUG_
std::cout << "DEPENDENCY_TYPE() : table["<<Ports::Calcium_Ports::TIME_DEPENDENCY<<"] : "<<
table[Ports::Calcium_Ports::TIME_DEPENDENCY] << std::endl;
std::cout << "DEPENDENCY_TYPE() : table["<<Ports::Calcium_Ports::ITERATION_DEPENDENCY<<"] : "<<
table[Ports::Calcium_Ports::ITERATION_DEPENDENCY] << std::endl;
std::cout << "DEPENDENCY_TYPE() : table["<<Ports::Calcium_Ports::UNDEFINED_DEPENDENCY<<"] : "<<
table[Ports::Calcium_Ports::UNDEFINED_DEPENDENCY] << std::endl;
+#endif
}
CalciumTypes::DependencyType> &table = (map<Ports::Calcium_Ports::DependencyType,
CalciumTypes::DependencyType>&)*this ;
+#ifdef _DEBUG_
std::cout << "DEPENDENCY_TYPE() : ::operator["<<c<<"]: " << table[c] << std::endl;
+#endif
assert( table.find( (Ports::Calcium_Ports::DependencyType)c ) != table.end() ) ;
return table[ (Ports::Calcium_Ports::DependencyType)c ] ;
// ATTENTION TESTER p184 si le pointeur est null
// ATTENTION TESTER Si le flag release si la sequence contient des chaines
// ou des object refs
+#ifdef _DEBUG_
std::cout << "----seq_u_manipulation::get_data(..)-- MARK 1 ------------------" << std::endl;
+#endif
InnerType * p_data = const_cast<seq_T &>(data).get_buffer(true);
+#ifdef _DEBUG_
std::cout << "----seq_u_manipulation::get_data(..)-- MARK 2 ------"<< p_data <<"------------" << std::endl;
+#endif
// Crée une nouvelle sequence propriétaire des données du buffer (pas de recopie)
// Les données seront automatiquement désallouées par appel interne à la méthode freebuf
template < typename DataManipulator, typename COUPLING_POLICY> void
GenericPort<DataManipulator, COUPLING_POLICY>::wakeupWaiting()
{
+#ifdef _DEBUG_
std::cout << "-------- wakeupWaiting ------------------" << std::endl;
+#endif
storedDatas_mutex.lock();
if (waitingForAnyDataId || waitingForConvenientDataId) {
+#ifdef _DEBUG_
std::cout << "-------- wakeupWaiting:signal --------" << std::endl;
std::cout << std::flush;
+#endif
cond_instance.signal();
}
storedDatas_mutex.unlock();
fflush(stdout);
fflush(stderr);
try {
+#ifdef _DEBUG_
// Affichage des donnees pour DEBUGging
cerr << "parametres emis: " << time << ", " << tag << endl;
DataManipulator::dump(dataParam);
+#endif
// L'intérêt des paramètres time et tag pour ce port est décidé dans la politique de couplage
// Il est possible de filtrer en prenant en compte uniquement un paramètre time/tag ou les deux
bool expectedDataReceived = false;
+#ifdef _DEBUG_
std::cout << "-------- Put : MARK 1 ------------------" << std::endl;
+#endif
if ( dataIds.empty() ) return;
+#ifdef _DEBUG_
std::cout << "-------- Put : MARK 1bis ------------------" << std::endl;
+#endif
// Recupere les donnees venant de l'ORB et relâche les structures CORBA
// qui n'auraient plus cours en sortie de méthode put
int nbOfIter = 0;
+#ifdef _DEBUG_
std::cout << "-------- Put : MARK 2 ------ "<< (dataIdIt == dataIds.end()) << "------------" << std::endl;
std::cout << "-------- Put : MARK 2bis "<< (*dataIdIt) <<"------------------" << std::endl;
+#endif
storedDatas_mutex.lock();
for (;dataIdIt != dataIds.end();++dataIdIt) {
+#ifdef _DEBUG_
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_
std::cout << "-------- Put : MARK 3bis -----"<< dataIdIt.operator*() <<"------------" << std::endl;
+#endif
DataId currentDataId=*dataIdIt;
+#ifdef _DEBUG_
std::cerr << "processing dataId : "<< currentDataId << std::endl;
std::cout << "-------- Put : MARK 4 ------------------" << std::endl;
+#endif
// Ajoute l'instance de la donnee a sa place dans la table de données
// ou remplace une instance précédente si elle existe
// <=> 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_
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_
std::cout << "-------- Put : MARK 6 ------------------" << std::endl;
+#endif
// Ajoute la donnee dans la table
wDataIt = storedDatas.insert(wDataIt, make_pair (currentDataId, data));
} 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_
std::cout << "-------- Put : MARK 7 ------------------" << std::endl;
+#endif
// Les données sont remplacées par les nouvelles valeurs
// lorsque que le dataId existe déjà
DataType old_data = (*wDataIt).second;
DataManipulator::delete_data (old_data);
}
+#ifdef _DEBUG_
std::cout << "-------- Put : MARK 8 ------------------" << std::endl;
+#endif
// Compte le nombre de dataIds à traiter
++nbOfIter;
+#ifdef _DEBUG_
std::cout << "-------- Put : waitingForConvenientDataId : " << waitingForConvenientDataId <<"---" << std::endl;
std::cout << "-------- Put : waitingForAnyDataId : " << waitingForAnyDataId <<"---" << std::endl;
std::cout << "-------- Put : currentDataId : " << currentDataId <<"---" << std::endl;
std::cout << "-------- Put : expectedDataId : " << expectedDataId <<"---" << std::endl;
std::cout << "-------- Put : MARK 9 ------------------" << std::endl;
+#endif
// A simplifier mais :
// - pas possible de mettre des arguments optionnels à cause
( waitingForConvenientDataId &&
isDataIdConveniant(storedDatas, expectedDataId, dummy1, dummy2, dummy3) )
) {
+#ifdef _DEBUG_
std::cout << "-------- Put : MARK 10 ------------------" << std::endl;
+#endif
//Doit pouvoir réveiller le get ici (a vérifier)
expectedDataReceived = true;
}
}
if (expectedDataReceived) {
+#ifdef _DEBUG_
std::cout << "-------- Put : MARK 11 ------------------" << std::endl;
+#endif
// si waitingForAnyDataId était positionné, c'est forcément lui qui a activer
// expectedDataReceived à true
if (waitingForAnyDataId)
// 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
fflush(stdout);fflush(stderr);
cond_instance.signal();
}
+#ifdef _DEBUG_
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_
std::cout << "-------- Put : MARK 13 ------------------" << std::endl;
+#endif
fflush(stdout);
fflush(stderr);
catch ( const SALOME_Exception & ex ) {
// On évite de laisser un mutex
storedDatas_mutex.unlock();
- std::cerr << ex;
THROW_SALOME_CORBA_EXCEPTION(ex.what(), SALOME::INTERNAL_ERROR);
}
bool isEqual, isBounded;
typedef typename DataManipulator::InnerType InnerType;
+#ifdef _DEBUG_
std::cout << "-------- Get : MARK 1 ------------------" << std::endl;
+#endif
expectedDataId = DataId(time,tag);
+#ifdef _DEBUG_
std::cout << "-------- Get : MARK 2 ------------------" << std::endl;
+#endif
typename DataTable::iterator wDataIt1;
// - 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_
std::cout << "-------- Get : MARK 3 ------------------" << std::endl;
+#endif
// L'ordre des différents tests est important
if ( isEqual ) {
+#ifdef _DEBUG_
std::cout << "-------- Get : MARK 4 ------------------" << std::endl;
+#endif
// La propriété de la données N'EST PAS transmise à l'utilisateur en mode CALCIUM.
// Si l'utilisateur supprime la donnée, storedDataIds devient incohérent
// C'est EraseDataId qui choisi ou non de supprimer la donnée
// Du coup interaction potentielle entre le 0 copy et gestion de l'historique
dataToTransmit = (*wDataIt1).second;
+#ifdef _DEBUG_
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);
std::copy(InIt1, InIt1 + N,
std::ostream_iterator< InnerType > (std::cout," "));
std::cout << std::endl;
+#endif
// Décide de la suppression de certaines instances de données
// La donnée contenu dans la structure CORBA et son dataId sont désallouées
// Méthode provenant de la COUPLING_POLICY
typename COUPLING_POLICY::template EraseDataIdProcessor<DataManipulator> processEraseDataId(*this);
processEraseDataId.apply(storedDatas,wDataIt1);
+#ifdef _DEBUG_
std::cout << "-------- Get : MARK 6 ------------------" << std::endl;
+#endif
break;
}
+#ifdef _DEBUG_
std::cout << "-------- Get : MARK 7 ------------------" << std::endl;
+#endif
//if ( isBounded() && COUPLING_POLICY::template needToProcessBoundedDataId() ) {
// Le DataId demandé n'est pas trouvé mais est encadré ET la politique de couplage
// l'interpolation.
// Les données calciulées sont donc stockées dans storedDatas.
// La propriété des données N'EST PAS transférée à l'utilisateur en mode CALCIUM.
+#ifdef _DEBUG_
std::cout << "-------- Get : MARK 8 ------------------" << std::endl;
+#endif
typename COUPLING_POLICY::template BoundedDataIdProcessor<DataManipulator> processBoundedDataId(*this);
//si static BDIP::apply(dataToTransmit,expectedDataId,wDataIt1);
// A déplacer en paramètre de la méthode précédente ?
storedDatas[expectedDataId]=dataToTransmit;
+#ifdef _DEBUG_
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);
std::ostream_iterator< InnerType > (std::cout," "));
std::cout << std::endl;
std::cout << "-------- Get : MARK 9 ------------------" << std::endl;
+#endif
typename COUPLING_POLICY::template EraseDataIdProcessor<DataManipulator> processEraseDataId(*this);
processEraseDataId.apply(storedDatas,wDataIt1);
// Réception bloquante sur le dataId demandé
// Si l'instance de donnée n'est pas trouvee
+#ifdef _DEBUG_
std::cout << "-------- Get : MARK 10 ------------------" << std::endl;
+#endif
//Positionné à faux dans la méthode put
waitingForConvenientDataId = true;
+#ifdef _DEBUG_
std::cout << "-------- Get : MARK 11 ------------------" << std::endl;
// Ici on attend que la méthode put recoive la donnée
std::cout << "-------- Get : waiting datas ------------------" << std::endl;
+#endif
fflush(stdout);fflush(stderr);
cond_instance.wait();
+#ifdef _DEBUG_
std::cout << "-------- Get : MARK 12 ------------------" << std::endl;
+#endif
}
} catch (...) {
// Deverouille l'acces a la table
storedDatas_mutex.unlock();
+#ifdef _DEBUG_
std::cout << "-------- Get : MARK 13 ------------------" << std::endl;
+#endif
// La propriété de la données N'EST PAS transmise à l'utilisateur en mode CALCIUM
// Si l'utilisateur supprime la donnée, storedDataIds devient incohérent
try {
storedDatas_mutex.lock();// Gérer les Exceptions ds le corps de la méthode
+#ifdef _DEBUG_
std::cout << "-------- Next : MARK 1 ---lastDataIdSet ("<<lastDataIdSet<<")---------------" << std::endl;
+#endif
typename DataTable::iterator wDataIt1;
wDataIt1 = storedDatas.end();
waitingForAnyDataId = false; break;
}
+#ifdef _DEBUG_
std::cout << "-------- Next : MARK 2 ------------------" << std::endl;
+#endif
//Positionné à faux dans la méthode put
waitingForAnyDataId = true;
+#ifdef _DEBUG_
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;
+#endif
fflush(stdout);fflush(stderr);
cond_instance.wait();
if (lastDataIdSet) {
+#ifdef _DEBUG_
std::cout << "-------- Next : MARK 4 ------------------" << std::endl;
+#endif
wDataIt1 = storedDatas.upper_bound(lastDataId);
} else {
+#ifdef _DEBUG_
std::cout << "-------- Next : MARK 5 ------------------" << std::endl;
+#endif
lastDataIdSet = true;
wDataIt1 = storedDatas.begin();
}
}
+#ifdef _DEBUG_
std::cout << "-------- Next : MARK 6 ------------------" << std::endl;
+#endif
t = getTime( (*wDataIt1).first );
tag = getTag ( (*wDataIt1).first );
dataToTransmit = (*wDataIt1).second;
+#ifdef _DEBUG_
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_
std::cout << "-------- Next : MARK 8 ------------------" << std::endl;
+#endif
} catch (...) {
+#ifdef _DEBUG_
std::cout << "-------- Next : MARK 8bis ------------------" << std::endl;
+#endif
waitingForAnyDataId = false;
storedDatas_mutex.unlock();
throw;
}
storedDatas_mutex.unlock();
+#ifdef _DEBUG_
std::cout << "-------- Next : MARK 9 ------------------" << std::endl;
+#endif
// La propriété de la données N'EST PAS transmise à l'utilisateur en mode CALCIUM
// Si l'utilisateur supprime la donnée, storedDataIds devient incohérent
CorbaPortTypePtr port = CorbaPortType::_narrow((*_my_ports)[i]);
//if (i) { PB1
copyOfData = DataManipulator::clone(data);
+#ifdef _DEBUG_
std::cout << "-------- GenericUsesPort::put : Copie de data("
//<< DataManipulator::getPointer(data)
<<") vers copyOfData ("
<<DataManipulator::getPointer(copyOfData)
<<")------------------" << std::endl;
+#endif
//} PB1
try {
port->put(*copyOfData,time,tag); // catcher les exceptions
{
if (_my_ports) delete _my_ports;
+#ifdef _DEBUG_
std::cerr << "GenericUsesPort::uses_port_changed" << endl;
+#endif
_my_ports = new Engines::DSC::uses_port(*new_uses_port);
}
bool notif) :
Engines_DSC_i(orb, poa, contId, instanceName, interfaceName)
{
+#ifdef _DEBUG_
std::cout << "--Superv_Component_i : MARK 1 ---- " << instanceName << "----" << std::endl;
+#endif
_my_basic_factory = new basic_port_factory();
_my_palm_factory = new palm_port_factory();
_my_calcium_factory = new calcium_port_factory();
search_result = the_type.find("CALCIUM_");
if (search_result == 0) {
+#ifdef _DEBUG_
std::cout << "---- Superv_Component_i::create_uses_data_port : MARK 1 ---- " << the_type.substr(search_result+8, the_type.length()) << "----" << std::endl;
+#endif
rtn_proxy = _my_calcium_factory->create_data_proxy(the_type.substr(search_result+8, the_type.length()));
}
add_port(port, port_name);
}
else if (s_port_type == "uses") {
+#ifdef _DEBUG_
std::cout << "---- Superv_Component_i::add_port : MARK 1 ---- " << std::endl;
+#endif
uses_port * port = create_uses_data_port(port_fab_type);
+#ifdef _DEBUG_
std::cout << "---- Superv_Component_i::add_port : MARK 2 ---- " << std::endl;
+#endif
add_port(port, port_name);
}
else
assert(port_name);
SpecificPortType * retPort;
+#ifdef _DEBUG_
std::cout << "---- Superv_Component_i::add_port : Mark 0 ---- " << port_name << "----" << std::endl;
+#endif
std::string s_port_type(port_type);
if (s_port_type == "provides") {
else if (s_port_type == "uses") {
uses_port * port = create_uses_data_port(port_fab_type);
add_port(port, port_name);
+#ifdef _DEBUG_
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_
std::cout << "---- Superv_Component_i::add_port : Mark 2 ---- " << retPort << "----" << std::endl;
+#endif
if ( retPort == NULL ) { delete port;
throw BadCast( LOC("La conversion vers le type de port demandé n'est pas possible " ));
}
