//=================== DESTROYER =============================
StatisticsCollector::~StatisticsCollector() {
if(isSubscribed("arrival",listener)){
unsubscribe("arrival", listener);
}
if(isSubscribed("arrivalTime",listener)){
unsubscribe("arrivalTime", listener);
}
}
void StatisticsCollector::finish(){
this->arrivalPercentage.recordAs("arrivalPercentage");
this->arrivalTime.recordAs("arrivalTime");
if(isSubscribed("arrival",listener)){
unsubscribe("arrival", listener);
}
if(isSubscribed("arrivalTime",listener)){
unsubscribe("arrivalTime", listener);
}
}
void EventManager::subscribe(LuaScriptRunner *subscriber, EventType eventType, ScriptContext context, bool failSilently)
{
// First, see if we're already subscribed
if(isSubscribed(subscriber, eventType) || isPendingSubscribed(subscriber, eventType))
return;
lua_State *L = LuaScriptRunner::getL();
// Make sure the script has the proper event listener
bool ok = LuaScriptRunner::loadFunction(L, subscriber->getScriptId(), eventDefs[eventType].function); // -- function
if(!ok)
{
if(!failSilently)
logprintf(LogConsumer::LogError, "Error subscribing to %s event: couldn't find handler function. Unsubscribing.",
eventDefs[eventType].name);
lua_pop(L, -1); // Remove function from stack
return;
}
removeFromPendingUnsubscribeList(subscriber, eventType);
Subscription s;
s.subscriber = subscriber;
s.context = context;
pendingSubscriptions[eventType].push_back(s);
anyPending = true;
lua_pop(L, -1); // Remove function from stack -- <<empty stack>>
}
void ProcessVariable::unsubscribe(Guard &guard)
{
guard.check(__FILE__, __LINE__, mutex);
// See comments in stop(): this->id is already 0, state==INIT.
if (isSubscribed(guard))
{
#ifdef CHECK_EVID
void *user = peek_evid_userptr(ev_id);
LOG_ASSERT(user == this);
#endif
evid _ev_id = ev_id;
ev_id = 0;
GuardRelease release(__FILE__, __LINE__, guard);
{
Guard ctx_guard(__FILE__, __LINE__, ctx);
LOG_ASSERT(ctx.isAttached(ctx_guard));
}
try
{
ca_clear_subscription(_ev_id);
}
catch (std::exception &e)
{
LOG_MSG("ProcessVariable::unsubscribe(%s): %s\n",
getName().c_str(), e.what());
}
catch (...)
{
LOG_MSG("ProcessVariable::unsubscribe(%s): Unknown Exception\n",
getName().c_str());
}
}
}
void PrimitiveShapeClassifier::configCallback(Config& config, uint32_t level)
{
boost::mutex::scoped_lock lock(mutex_);
min_points_num_ = config.min_points_num;
sac_max_iterations_ = config.sac_max_iterations;
sac_distance_threshold_ = config.sac_distance_threshold;
if (config.sac_radius_limit_min < config.sac_radius_limit_max) {
sac_radius_limit_min_ = config.sac_radius_limit_min;
sac_radius_limit_max_ = config.sac_radius_limit_max;
} else {
config.sac_radius_limit_min = sac_radius_limit_min_;
config.sac_radius_limit_max = sac_radius_limit_max_;
}
box_threshold_ = config.box_threshold;
circle_threshold_ = config.circle_threshold;
if (queue_size_ = config.queue_size) {
queue_size_ = config.queue_size;
if (isSubscribed()) {
unsubscribe();
subscribe();
}
}
}
void MainWindow::formChannelList(){
if (m_availableChannelsQuery->getChannels().size() == 0 ) return;
else
{
m_availableChannels = m_availableChannelsQuery->getChannels();
}
m_subscribedChannels = m_subscribedChannelsQuery->getChannels();
QListWidget * listWidget = ui->channelsListWidget;
QListWidget * subscribedListWidget = ui->subscribedListWidget;
// Tab - channels
while(listWidget->count()>0)
{
listWidget->takeItem(0);
}
foreach (Channel s, m_availableChannels){
QListWidgetItem * item = new QListWidgetItem(s.getName());
if (isSubscribed(s.getName())){
item->setBackgroundColor(Qt::lightGray);
}
listWidget->addItem(item);
}
/// Creates a SymmetryOperation object from its identifier.
SymmetryOperation
SymmetryOperationFactoryImpl::createSymOp(const std::string &identifier) {
if (!isSubscribed(identifier)) {
subscribeSymOp(identifier);
}
return SymmetryOperation(m_prototypes[identifier]);
}
void EventManager::unsubscribe(LuaScriptRunner *subscriber, EventType eventType)
{
if((isSubscribed(subscriber, eventType) || isPendingSubscribed(subscriber, eventType)) && !isPendingUnsubscribed(subscriber, eventType))
{
removeFromPendingSubscribeList(subscriber, eventType);
pendingUnsubscriptions[eventType].push_back(subscriber);
anyPending = true;
}
}
void PointGroupFactoryImpl::subscribePointGroup(
const std::string &hmSymbol, const std::string &generatorString,
const std::string &description) {
if (isSubscribed(hmSymbol)) {
throw std::invalid_argument(
"Point group with this symbol is already registered.");
}
PointGroupGenerator_sptr generator = boost::make_shared<PointGroupGenerator>(
hmSymbol, generatorString, description);
subscribe(generator);
}
void MainWindow::onChannelsListChanged(int index){
qDebug() << index;
if (index<0) return ;
if (isSubscribed(index)){
ui->channelActionButton->setText("Unsubscribe");
}else{
ui->channelActionButton->setText("Subscribe");
}
}
void MainWindow::onChannelButtonPressed()
{
if (m_session.isValid()){
int index = ui->channelsListWidget->currentRow();
if (index < 0) return;
QString channelName = ui->channelsListWidget->item(index)->text();
Channel channel(channelName);
if (isSubscribed(index)){
//do unsubscribe
m_unsubscribeChannelQuery->setQuery(channel,m_session);
m_unsubscribeChannelQuery->doRequest();
}else{
//do subscribe
m_subscribeChannelQuery->setQuery(channel,m_session);
m_subscribeChannelQuery->doRequest();
}
}
}
bool ListJobs::v_caseMessage( af::Msg * msg)
{
switch( msg->type())
{
case af::Msg::TJobsList:
{
if( updateItems( msg) && (af::Environment::VISOR() == false))
{
getUserJobsOrder();
}
if( false == isSubscribed() )
{
if( af::Environment::VISOR() == false )
{
m_view->scrollToBottom();
}
subscribe();
}
calcTotals();
break;
}
case af::Msg::TUserJobsOrder:
{
af::MCGeneral ids( msg);
if( ids.getId() == MonitorHost::getUid())
sortMatch( ids.getList());
break;
}
default:
return false;
}
return true;
}
void ProcessVariable::subscribe(Guard &guard)
{
guard.check(__FILE__, __LINE__, mutex);
if (dbr_type == 0)
throw GenericException(__FILE__, __LINE__,
"Cannot subscribe to %s, never connected",
getName().c_str());
// Prevent multiple subscriptions
if (isSubscribed(guard))
return;
// While we were unlocked, a disconnect or stop() could have happend,
// in which case we need to bail out.
if (id == 0 || state != CONNECTED)
{
LOG_MSG("'%s': Skipped subscription, state %s, id 0x%lu.\n",
getName().c_str(), getStateStr(guard), (unsigned long) id);
return;
}
chid _id = id;
evid _ev_id = 0;
DbrType _type = dbr_type;
DbrCount _count = dbr_count;
{ // Release around CA call??
// -- GuardRelease release(__FILE__, __LINE__, guard);
// Right now, could a stop() and ca_clear_channel(id) happen,
// so that ca_create_subscription() uses an invalid id?
//
// Task A, CAC client:
// control_callback, pvConnected, subscribe
//
// Task B, Engine or HTTPD:
// stop, clear_channel
//
// LockTest.cpp indicates that the clear_channel() will wait
// for the CAC library to leabe the control_callback.
// So even though we unlock the ProcessVariable and somebody
// could invoke stop() and set id=0, we have the copied _id,
// and the ca_clear_channel(id) won't happen until we leave
// the control_callback.
// This of course only handles the use case of the engine
// where subscribe is invoked from control_callback & pvConnected.
// to be on the safe side, we keep the guard and prevent a stop(),
// until we find a deadlock that forces us to reconsider....
{
int status;
try
{
status = ca_create_subscription(_type, _count, _id,
DBE_LOG | DBE_ALARM,
value_callback, this, &_ev_id);
}
catch (std::exception &e)
{
LOG_MSG("ProcessVariable::subscribe(%s): %s\n",
getName().c_str(), e.what());
}
catch (...)
{
LOG_MSG("ProcessVariable::subscribe(%s): Unknown Exception\n",
getName().c_str());
}
if (status != ECA_NORMAL)
{
LOG_MSG("%s: ca_create_subscription failed: %s\n",
getName().c_str(), ca_message(status));
return;
}
Guard ctx_guard(__FILE__, __LINE__, ctx);
ctx.requestFlush(ctx_guard);
}
}
ev_id = _ev_id;
LOG_ASSERT(ev_id != 0);
#ifdef CHECK_EVID
void *user = peek_evid_userptr(ev_id);
LOG_ASSERT(user == this);
#endif
}
libember::glow::GlowStreamCollection* StreamConverter::create(libember::glow::GlowStreamCollection* root, gadget::StreamManager const& manager)
{
typedef std::vector<gadget::Parameter*> ParameterCollection;
std::map<int, std::unique_ptr<ParameterCollection> > dic;
{
auto it = std::begin(manager);
auto const last= std::end(manager);
for (; it != last; ++it)
{
auto& parameter = *it;
auto const identifier = parameter->streamIdentifier();
if (dic.find(identifier) == std::end(dic))
{
dic[identifier] = std::unique_ptr<ParameterCollection>(new ParameterCollection());
}
dic[identifier]->push_back(parameter);
}
}
{
for(auto& pair : dic)
{
auto& streams = *pair.second;
auto const identifier = pair.first;
auto const size = streams.size();
if (size == 1 && streams.front()->hasStreamDescriptor() == false)
{
auto parameter = streams.front();
if (parameter->isSubscribed() && parameter->isDirty())
{
auto entry = SingleStreamEntryFactory::create(parameter);
root->insert(entry);
}
}
else if (size >= 1)
{
auto const first = std::begin(streams);
auto const last = std::end(streams);
auto const result = std::max_element(first, last, [](decltype(*first) max, decltype(*first) cur) -> bool
{
if (max->hasStreamDescriptor() && cur->hasStreamDescriptor())
{
return cur->streamDescriptor()->offset() > max->streamDescriptor()->offset();
}
else if (max->hasStreamDescriptor())
{
return false;
}
else if (cur->hasStreamDescriptor())
{
return true;
}
return false;
});
auto const isSubscribed = std::any_of(first, last, [](decltype(*first) stream) -> bool
{
return stream->isSubscribed() && stream->isDirty();
});
if (result != last && isSubscribed)
{
auto descriptor = (*result)->streamDescriptor();
auto const format = descriptor->format();
auto const offset = descriptor->offset();
auto const size = offset + format.size();
auto buffer = std::vector<unsigned char>(size, 0x00);
for(auto parameter : streams)
{
encode(parameter, std::begin(buffer), std::end(buffer));
parameter->clearDirtyState();
}
root->insert(identifier, std::begin(buffer), std::end(buffer));
}
}
}
}
return root;
}
/// Unsubscribes a symmetry operation from the factory
void SymmetryOperationFactoryImpl::unsubscribeSymOp(
const std::string &identifier) {
if (isSubscribed(identifier)) {
m_prototypes.erase(identifier);
}
}
/// Subscribes symmetry operation into factory, using the supplied alias as key.
void SymmetryOperationFactoryImpl::subscribe(
const std::string &alias, const SymmetryOperation &prototype) {
if (!isSubscribed(alias)) {
m_prototypes.insert(std::make_pair(alias, prototype));
}
}
bool MainWindow::isSubscribed(int index)
{
QString channelName = ui->channelsListWidget->item(index)->text();
return isSubscribed(channelName);
}
