int cp_fini(Superv_Component_i *component,char *nom, int n);
int cp_fint(Superv_Component_i *component,char *nom, float t);
+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);
//TODO: ajouter les prototypes pour eviter les pbs de passage par valeur
InfoType ecp_fint_ (void * component, char* nomVar, float t);
InfoType ecp_fini_ (void * component, char* nomVar, int i);
+InfoType ecp_efft_ (void * component, char* nomVar, float t);
+InfoType ecp_effi_ (void * component, char* nomVar, int i);
/************************************/
/* INTERFACES DE LECTURE EN 0 COPIE */
InfoType info = ecp_fint_(component,nomvar,t);
return info;
}
+
+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;
}
+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*,);
extern "C" CalciumTypes::InfoType ecp_cd_ (void * component, char* instanceName);
extern "C" CalciumTypes::InfoType ecp_fini_ (void * component, char* nomVar, int i);
extern "C" CalciumTypes::InfoType ecp_fint_ (void * component, char* nomVar, float t);
+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 EraseDataIdBeforeOrAfterTagProcessor;
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 EraseDataIdBeforeOrAfterTagProcessor;
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
+//Remove DataId before or after a given time or tag
template < typename DataManipulator >
-struct CalciumCouplingPolicy::EraseDataIdBeforeTagProcessor
+struct CalciumCouplingPolicy::EraseDataIdBeforeOrAfterTagProcessor
{
CalciumCouplingPolicy &_couplingPolicy;
- EraseDataIdBeforeTagProcessor(CalciumCouplingPolicy &couplingPolicy):
+ EraseDataIdBeforeOrAfterTagProcessor(CalciumCouplingPolicy &couplingPolicy):
_couplingPolicy(couplingPolicy) {};
template < typename Container,typename TimeType,typename TagType >
- void apply(Container & storedDatas, TimeType time, TagType tag) const
+ void apply(Container & storedDatas, TimeType time, TagType tag, bool before) const
{
typedef typename Container::iterator iterator;
+ typedef typename Container::reverse_iterator riterator;
if(_couplingPolicy._dependencyType == CalciumTypes::TIME_DEPENDENCY)
{
- iterator it=storedDatas.begin();
- while(it != storedDatas.end() && it->first.first <= time)
+ if(before)
{
- DataManipulator::delete_data(it->second);
- storedDatas.erase(it);
- it=storedDatas.begin();
+ iterator it=storedDatas.begin();
+ while(it != storedDatas.end() && it->first.first <= time)
+ {
+ DataManipulator::delete_data(it->second);
+ storedDatas.erase(it);
+ it=storedDatas.begin();
+ }
+ }
+ else
+ {
+ riterator it=storedDatas.rbegin();
+ while(it != storedDatas.rend() && it->first.first >= time)
+ {
+ DataManipulator::delete_data(it->second);
+ storedDatas.erase(it->first);
+ it=storedDatas.rbegin();
+ }
}
}
else
{
- iterator it=storedDatas.begin();
- while(it != storedDatas.end() && it->first.second <= tag)
+ if(before)
+ {
+ iterator it=storedDatas.begin();
+ while(it != storedDatas.end() && it->first.second <= tag)
+ {
+ DataManipulator::delete_data(it->second);
+ storedDatas.erase(it);
+ it=storedDatas.begin();
+ }
+ }
+ else
{
- DataManipulator::delete_data(it->second);
- storedDatas.erase(it);
- it=storedDatas.begin();
+ riterator it=storedDatas.rbegin();
+ while(it != storedDatas.rend() && it->first.second >= tag)
+ {
+ DataManipulator::delete_data(it->second);
+ storedDatas.erase(it->first);
+ it=storedDatas.rbegin();
+ }
}
}
}
<< portDependencyType << " must be iteration mode."));
}
- port->calcium_erase(0., i);
+ port->calcium_erase(0., i,true);
std::stringstream msg;
msg << "i<=" << i ;
<< portDependencyType << " must be time mode."));
}
- port->calcium_erase(t, 0);
+ port->calcium_erase(t, 0,true);
std::stringstream msg;
msg << "t<=" << t ;
Engines_DSC_interface::writeEvent("CP_FINT",containerName,componentName,nomVar.c_str(),"",msg.str().c_str());
};
+
+ 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,false);
+
+ 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,false);
+
+ std::stringstream msg;
+ msg << "t>=" << t ;
+ Engines_DSC_interface::writeEvent("CP_EFFT",containerName,componentName,nomVar.c_str(),"",msg.str().c_str());
+
+ };
+
};
#endif
const Engines::DSC::Message message) { \
if ( message == Engines::DSC::AddingConnection) \
{ \
- _disconnect_mutex.lock(); \
+ _disconnect_mutex.lock(); \
_mustnotdisconnect++; \
- _disconnect_mutex.unlock(); \
+ _disconnect_mutex.unlock(); \
} \
else if ( message == Engines::DSC::RemovingConnection ) \
{ \
} \
} \
\
- inline void calcium_erase(float t,long i) \
+ inline void calcium_erase(float t,long i, bool before) \
{ \
- erase(t,i); \
+ erase(t,i,before); \
} \
}; \
virtual InterpolationSchem getInterpolationSchem () const =0;
virtual ExtrapolationSchem getExtrapolationSchem () const =0;
- virtual void calcium_erase (float t,long i) {};
+ virtual void calcium_erase (float t,long i, bool before) {};
};
#endif
*err=cp_fin((void *)*compo,(int)*dep);
}
+/**************************************/
+/* ERASE INTERFACE */
+/**************************************/
void F_FUNC(cpfini,CPFINI)(long *compo,STR_PSTR(nom),cal_int *i, cal_int *err STR_PLEN(nom));
void F_FUNC(cpfint,CPFINT)(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));
+void F_FUNC(cpefft,CPEFFT)(long *compo,STR_PSTR(nom),float *t, cal_int *err STR_PLEN(nom));
void F_FUNC(cpfini,CPFINI)(long *compo,STR_PSTR(nom),cal_int *i, cal_int *err STR_PLEN(nom))
{
free_str1(cnom);
}
+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 {
+ struct EraseDataIdBeforeOrAfterTagProcessor {
- EraseDataIdBeforeTagProcessor(CouplingPolicy couplingPolicy) {};
+ EraseDataIdBeforeOrAfterTagProcessor(CouplingPolicy couplingPolicy) {};
template < typename Container , typename TimeType , typename TagType >
- void apply(Container & storedDatas, TimeType time, TagType tag ) const {
+ void apply(Container & storedDatas, TimeType time, TagType tag, bool before ) const {
typedef typename Container::key_type key_type;
typedef typename Container::value_type value_type;
typedef typename Container::iterator iterator;
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 );
+ template <typename TimeType,typename TagType> void erase(TimeType time, TagType tag, bool before );
private:
template < typename DataManipulator, typename COUPLING_POLICY >
template <typename TimeType,typename TagType>
void
-GenericPort<DataManipulator, COUPLING_POLICY>::erase(TimeType time, TagType tag)
+GenericPort<DataManipulator, COUPLING_POLICY>::erase(TimeType time, TagType tag, bool before)
{
- typename COUPLING_POLICY::template EraseDataIdBeforeTagProcessor<DataManipulator> processEraseDataId(*this);
- processEraseDataId.apply(storedDatas,time,tag);
+ typename COUPLING_POLICY::template EraseDataIdBeforeOrAfterTagProcessor<DataManipulator> processEraseDataId(*this);
+ processEraseDataId.apply(storedDatas,time,tag,before);
}
// Version du Get en 0 copy
