These requests remove all dataid before a given time (cpefft) or iteration number (cpeffi)
C, Fortran and Python API are implemented
int cp_llg(Superv_Component_i *component,int dep,float *ti,float *tf,int *niter,char *nom,int nmax,int *nval,long *lval);
int cp_lln(Superv_Component_i *component,int dep,float *ti,float *tf,int *niter,char *nom,int nmax,int *nval,long *lval);
+int cp_effi(Superv_Component_i *component,char *nom, int n);
+int cp_efft(Superv_Component_i *component,char *nom, float t);
+
int cp_fin(Superv_Component_i *component,int cp_end);
typedef int InfoType;
typedef char bool;
+//TODO: ajouter les prototypes pour eviter les pbs de passage par valeur
+InfoType ecp_efft_ (void * component, char* nomVar, float t);
+InfoType ecp_effi_ (void * component, char* nomVar, int i);
/************************************/
/* INTERFACES DE LECTURE EN 0 COPIE */
CALCIUM_ECR_INTERFACE_C_(eln_fort_,float ,cal_int,long ,long,,);
+/***************************/
+/* Interface for cleaning */
+/***************************/
+
+InfoType cp_effi (void * component, char * nomvar, int i)
+{
+ InfoType info = ecp_effi_(component,nomvar,i);
+ return info;
+}
+
+InfoType cp_efft (void * component, char * nomvar, float t)
+{
+ InfoType info = ecp_efft_(component,nomvar,t);
+ return info;
+}
return CalciumTypes::CPOK;
}
+// Interface for cleaning
+extern "C" CalciumTypes::InfoType
+ecp_effi_ (void * component, char* nomvar, int i)
+{
+ Superv_Component_i * _component = static_cast<Superv_Component_i *>(component);
+ try
+ {
+ CalciumInterface::ecp_effi( *_component,nomvar,i);
+ }
+ catch ( const CalciumException & ex)
+ {
+ DEBTRACE( ex.what() );
+ return ex.getInfo();
+ }
+ return CalciumTypes::CPOK;
+
+}
+
+extern "C" CalciumTypes::InfoType
+ecp_efft_ (void * component, char* nomvar, float t)
+{
+ Superv_Component_i * _component = static_cast<Superv_Component_i *>(component);
+ try
+ {
+ CalciumInterface::ecp_efft( *_component,nomvar,t);
+ }
+ catch ( const CalciumException & ex)
+ {
+ DEBTRACE( ex.what() );
+ return ex.getInfo();
+ }
+ return CalciumTypes::CPOK;
+}
+
// INTERFACE C/CPP pour les chaines de caractères
// Le paramètre supplémentaire strsize n'étant pas utilisé
// j'utilise la génération par la macro CALCIUM_C2CPP_INTERFACE_(str,char*,);
/* Déclaration de ecp_fin */
extern "C" CalciumTypes::InfoType ecp_fin_ (void * component, int code);
extern "C" CalciumTypes::InfoType ecp_cd_ (void * component, char* instanceName);
+extern "C" CalciumTypes::InfoType ecp_effi_ (void * component, char* nomVar, int i);
+extern "C" CalciumTypes::InfoType ecp_efft_ (void * component, char* nomVar, float t);
#endif
template <typename DataManipulator,
class EnableIf > friend class BoundedDataIdProcessor;
template <typename DataManipulator > friend class EraseDataIdProcessor;
+ template <typename DataManipulator > friend class EraseDataIdBeforeTagProcessor;
template <typename DataManipulator > friend class DisconnectProcessor;
typedef CalciumTypes::DependencyType DependencyType;
class EnableIf = void > struct BoundedDataIdProcessor;
//template <typename DataManipulator> struct BoundedDataIdProcessor;
template <typename DataManipulator> struct EraseDataIdProcessor;
+ template <typename DataManipulator> struct EraseDataIdBeforeTagProcessor;
template <typename DataManipulator> struct DisconnectProcessor;
// Renvoie isEqual si le dataId attendu est trouvé dans storedDataIds :
return isEqual || isBounded;
}
+//Remove DataId before a given time or tag
+template < typename DataManipulator >
+struct CalciumCouplingPolicy::EraseDataIdBeforeTagProcessor
+{
+ CalciumCouplingPolicy &_couplingPolicy;
+
+ EraseDataIdBeforeTagProcessor(CalciumCouplingPolicy &couplingPolicy):
+ _couplingPolicy(couplingPolicy) {};
+
+ template < typename Container,typename TimeType,typename TagType >
+ void apply(Container & storedDatas, TimeType time, TagType tag) const
+ {
+ typedef typename Container::iterator iterator;
+
+ if(_couplingPolicy._dependencyType == CalciumTypes::TIME_DEPENDENCY)
+ {
+ iterator it=storedDatas.begin();
+ while(it != storedDatas.end() && it->first.first <= time)
+ {
+ DataManipulator::delete_data(it->second);
+ storedDatas.erase(it);
+ it=storedDatas.begin();
+ }
+ }
+ else
+ {
+ iterator it=storedDatas.begin();
+ while(it != storedDatas.end() && it->first.second <= tag)
+ {
+ DataManipulator::delete_data(it->second);
+ storedDatas.erase(it);
+ it=storedDatas.begin();
+ }
+ }
+ }
+};
+
// TODO :PAS ENCORE TESTE AVEC UN NIVEAU POSITIONNE
// Supprime les DataId et les données associées
// du container associatif quand le nombre
ecp_ecriture<T1,T1> (component,dependencyType,t,i,nomVar,bufferLength,data);
};
+ static void
+ ecp_effi(Superv_Component_i & component,const std::string & nomVar,long const & i)
+ {
+ CORBA::String_var componentName=component.instanceName();
+ std::string containerName=component.getContainerName();
+
+ if (nomVar.empty())
+ {
+ Engines_DSC_interface::writeEvent("CP_EFFI",containerName,componentName,"",CPMESSAGE[CalciumTypes::CPNMVR],"");
+ throw CalciumException(CalciumTypes::CPNMVR, LOC("Empty variable name"));
+ }
+
+ calcium_provides_port* port;
+
+ try
+ {
+ port = component.Superv_Component_i::get_port< calcium_provides_port >(nomVar.c_str());
+ }
+ catch ( const Superv_Component_i::PortNotDefined & ex)
+ {
+ Engines_DSC_interface::writeEvent("CP_EFFI",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPNMVR],ex.what());
+ throw (CalciumException(CalciumTypes::CPNMVR,ex));
+ }
+ catch ( const Superv_Component_i::PortNotConnected & ex)
+ {
+ Engines_DSC_interface::writeEvent("CP_EFFI",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPLIEN],ex.what());
+ throw (CalciumException(CalciumTypes::CPLIEN,ex));
+ }
+ catch ( const Superv_Component_i::BadCast & ex)
+ {
+ Engines_DSC_interface::writeEvent("CP_EFFI",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPTPVR],ex.what());
+ throw (CalciumException(CalciumTypes::CPTPVR,ex));
+ }
+
+ // get dependency mode
+ CalciumTypes::DependencyType portDependencyType = port->getDependencyType();
+
+ if ( portDependencyType == CalciumTypes::UNDEFINED_DEPENDENCY )
+ {
+ Engines_DSC_interface::writeEvent("CP_EFFI",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPIT],"Dependency mode is undefined");
+ throw CalciumException(CalciumTypes::CPIT, LOC(OSS()<<"Dependency mode of variable " << nomVar << " is undefined."));
+ }
+
+ if ( portDependencyType != CalciumTypes::ITERATION_DEPENDENCY )
+ {
+ Engines_DSC_interface::writeEvent("CP_EFFI",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPIT],
+ "Dependency mode must be iteration mode");
+ throw CalciumException(CalciumTypes::CPITVR, LOC(OSS()<<"Dependency mode of variable " << nomVar << ": "
+ << portDependencyType << " must be iteration mode."));
+ }
+
+ port->calcium_erase(0., i);
+
+ std::stringstream msg;
+ msg << "i<=" << i ;
+ Engines_DSC_interface::writeEvent("CP_EFFI",containerName,componentName,nomVar.c_str(),"",msg.str().c_str());
+
+ };
+
+ static void
+ ecp_efft(Superv_Component_i & component,const std::string & nomVar,double const & t)
+ {
+ CORBA::String_var componentName=component.instanceName();
+ std::string containerName=component.getContainerName();
+
+ if (nomVar.empty())
+ {
+ Engines_DSC_interface::writeEvent("CP_EFFT",containerName,componentName,"",CPMESSAGE[CalciumTypes::CPNMVR],"");
+ throw CalciumException(CalciumTypes::CPNMVR, LOC("Empty variable name"));
+ }
+
+ calcium_provides_port* port;
+
+ try
+ {
+ port = component.Superv_Component_i::get_port< calcium_provides_port >(nomVar.c_str());
+ }
+ catch ( const Superv_Component_i::PortNotDefined & ex)
+ {
+ Engines_DSC_interface::writeEvent("CP_EFFT",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPNMVR],ex.what());
+ throw (CalciumException(CalciumTypes::CPNMVR,ex));
+ }
+ catch ( const Superv_Component_i::PortNotConnected & ex)
+ {
+ Engines_DSC_interface::writeEvent("CP_EFFT",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPLIEN],ex.what());
+ throw (CalciumException(CalciumTypes::CPLIEN,ex));
+ }
+ catch ( const Superv_Component_i::BadCast & ex)
+ {
+ Engines_DSC_interface::writeEvent("CP_EFFT",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPTPVR],ex.what());
+ throw (CalciumException(CalciumTypes::CPTPVR,ex));
+ }
+
+ // get dependency mode
+ CalciumTypes::DependencyType portDependencyType = port->getDependencyType();
+
+ if ( portDependencyType == CalciumTypes::UNDEFINED_DEPENDENCY )
+ {
+ Engines_DSC_interface::writeEvent("CP_EFFT",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPIT],"Dependency mode is undefined");
+ throw CalciumException(CalciumTypes::CPIT, LOC(OSS()<<"Dependency mode of variable " << nomVar << " is undefined."));
+ }
+
+ if ( portDependencyType != CalciumTypes::TIME_DEPENDENCY )
+ {
+ Engines_DSC_interface::writeEvent("CP_EFFT",containerName,componentName,nomVar.c_str(),CPMESSAGE[CalciumTypes::CPIT],
+ "Dependency mode must be time mode");
+ throw CalciumException(CalciumTypes::CPITVR, LOC(OSS()<<"Dependency mode of variable " << nomVar << ": "
+ << portDependencyType << " must be time mode."));
+ }
+
+ port->calcium_erase(t, 0);
+
+ std::stringstream msg;
+ msg << "t<=" << t ;
+ Engines_DSC_interface::writeEvent("CP_EFFT",containerName,componentName,nomVar.c_str(),"",msg.str().c_str());
+
+ };
};
#endif
virtual void provides_port_changed(int connection_nbr, \
const Engines::DSC::Message message) { \
if ( message == Engines::DSC::AddingConnection) \
- { \
- _disconnect_mutex.lock(); \
- _mustnotdisconnect++; \
- _disconnect_mutex.unlock(); \
- } \
+ { \
+ _disconnect_mutex.lock(); \
+ _mustnotdisconnect++; \
+ _disconnect_mutex.unlock(); \
+ } \
else if ( message == Engines::DSC::RemovingConnection ) \
- { \
- disconnect(false); \
- } \
+ { \
+ disconnect(false); \
+ } \
+ } \
+ \
+ inline void calcium_erase(float t,long i) \
+ { \
+ erase(t,i); \
} \
}; \
virtual InterpolationSchem getInterpolationSchem () const =0;
virtual ExtrapolationSchem getExtrapolationSchem () const =0;
+ virtual void calcium_erase (float t,long i) {};
};
#endif
*err=cp_fin((void *)*compo,(int)*dep);
}
+void F_FUNC(cpeffi,CPEFFI)(long *compo,STR_PSTR(nom),cal_int *i, cal_int *err STR_PLEN(nom));
+void F_FUNC(cpefft,CPEFFT)(long *compo,STR_PSTR(nom),float *t, cal_int *err STR_PLEN(nom));
+
+void F_FUNC(cpeffi,CPEFFI)(long *compo,STR_PSTR(nom),cal_int *i, cal_int *err STR_PLEN(nom))
+{
+ char* cnom=fstr1(STR_PTR(nom),STR_LEN(nom));
+ *err=cp_effi((void *)*compo,cnom,*i);
+ free_str1(cnom);
+}
+
+void F_FUNC(cpefft,CPEFFT)(long *compo,STR_PSTR(nom),float *t, cal_int *err STR_PLEN(nom))
+{
+ char* cnom=fstr1(STR_PTR(nom),STR_LEN(nom));
+ *err=cp_efft((void *)*compo,cnom,*t);
+ free_str1(cnom);
+}
+
/**************************************/
/* INTERFACES DE LECTURE */
/**************************************/
}
};
+ // Remove all DataId from a container before a given time or tag
+ template <typename DataManipulator>
+ struct EraseDataIdBeforeTagProcessor {
+
+ EraseDataIdBeforeTagProcessor(CouplingPolicy couplingPolicy) {};
+
+ template < typename Container , typename TimeType , typename TagType >
+ void apply(Container & storedDatas, TimeType time, TagType tag ) const {
+ typedef typename Container::key_type key_type;
+ typedef typename Container::value_type value_type;
+ typedef typename Container::iterator iterator;
+ }
+ };
+
// Permet de réveiller les méthodes d'un GenericPort en attente
// depuis une CouplingPolicy
virtual void wakeupWaiting(){};
template <typename TimeType,typename TagType> DataType next(TimeType &t, TagType &tag );
void close (PortableServer::POA_var poa, PortableServer::ObjectId_var id);
void wakeupWaiting();
+ template <typename TimeType,typename TagType> void erase(TimeType time, TagType tag );
private:
}
+// erase data before time or tag
+template < typename DataManipulator, typename COUPLING_POLICY >
+template <typename TimeType,typename TagType>
+void
+GenericPort<DataManipulator, COUPLING_POLICY>::erase(TimeType time, TagType tag)
+{
+ typename COUPLING_POLICY::template EraseDataIdBeforeTagProcessor<DataManipulator> processEraseDataId(*this);
+ processEraseDataId.apply(storedDatas,time,tag);
+}
// Version du Get en 0 copy
// ( n'effectue pas de recopie de la donnée trouvée dans storedDatas )
