void net_device_entry::handle_timer_expired(void* user_data) { NOT_IN_USE(user_data); auto_unlocker lock(m_lock); net_device_val* p_ndv = dynamic_cast<net_device_val*>(m_val); if (p_ndv) { if(m_bond == net_device_val::ACTIVE_BACKUP) { if(p_ndv->update_active_backup_slaves()) { //active slave was changed notify_observers(); } } else if(m_bond == net_device_val::LAG_8023ad){ if(p_ndv->update_active_slaves()) { //slave state was changed g_p_event_handler_manager->unregister_timer_event(this, m_timer_handle); m_timer_handle = g_p_event_handler_manager->register_timer_event(SLAVE_CHECK_TIMER_PERIOD_MSEC, this, PERIODIC_TIMER, 0); notify_observers(); } else { if (timer_count >= 0) { timer_count++; if (timer_count == SLAVE_CHECK_FAST_NUM_TIMES) { timer_count = -1; g_p_event_handler_manager->unregister_timer_event(this, m_timer_handle); m_timer_handle = g_p_event_handler_manager->register_timer_event(SLAVE_CHECK_TIMER_PERIOD_MSEC, this, PERIODIC_TIMER, 0); } } } } } }
virtual void set_item_model(i_item_model& aItemModel) { if (iModel == &aItemModel) return; if (has_item_model()) item_model().unsubscribe(*this); unset_current_index(); i_item_model* oldModel = iModel; iModel = &aItemModel; item_model().subscribe(*this); if (oldModel == 0) notify_observers(i_item_selection_model_subscriber::NotifyItemModelAdded, item_model()); else notify_observers(i_item_selection_model_subscriber::NotifyItemModelChanged, item_model(), *oldModel); }
virtual void set_mode(item_selection_mode aMode) { if (iMode == aMode) return; iMode = aMode; notify_observers(i_item_selection_model_subscriber::NotifySelectionModeChanged, mode()); }
virtual void setting_changed(i_setting& aExistingSetting) { setting_list::iterator iter = iSettings.find(setting::key_type(aExistingSetting.id())); if (iter == iSettings.end()) throw setting_not_found(); notify_observers(i_subscriber::NotifySettingChanged, *iter); }
void bound (const ioa::bound_t result) { switch (result) { case ioa::BIND_KEY_EXISTS_RESULT: assert (false); case ioa::OUTPUT_AUTOMATON_DNE_RESULT: assert (false); break; case ioa::INPUT_AUTOMATON_DNE_RESULT: assert (false); break; case ioa::BINDING_EXISTS_RESULT: assert (false); break; case ioa::OUTPUT_ACTION_UNAVAILABLE_RESULT: assert (false); break; case ioa::INPUT_ACTION_UNAVAILABLE_RESULT: assert (false); break; case ioa::BOUND_RESULT: // Okay. m_bound = true; notify_observers (); break; } }
void Enemy::step() { //body->ApplyForce(b2Vec2(.0f, .0f), b2Vec2(.0f, .0f)); b2Vec2 f = b2Vec2(target->get_x_position(), target->get_y_position()); b2Vec2 p = body->GetWorldPoint(b2Vec2(0.0f, 0.0f)); body->ApplyForce(f, p); notify_observers(); }
virtual void set_current_index(const item_model_index& aIndex) { if (iCurrentIndex == aIndex) return; optional_item_model_index previousIndex = iCurrentIndex; iCurrentIndex = aIndex; notify_observers(i_item_selection_model_subscriber::NotifyCurrentIndexChanged, iCurrentIndex, previousIndex); current_index_changed.trigger(iCurrentIndex, previousIndex); }
virtual void unset_current_index() { if (iCurrentIndex == boost::none) return; optional_item_model_index previousIndex = iCurrentIndex; iCurrentIndex = boost::none; notify_observers(i_item_selection_model_subscriber::NotifyCurrentIndexChanged, iCurrentIndex, previousIndex); current_index_changed.trigger(iCurrentIndex, previousIndex); }
virtual void delete_setting(i_setting& aExistingSetting) { setting_list::iterator iter = iSettings.find(setting::key_type(aExistingSetting.id())); if (iter == iSettings.end()) throw setting_not_found(); notify_observers(i_subscriber::NotifySettingDeleted, *iter); iSettings.erase(iter); save(); }
bool notify::add(const notify_entry& aEntry) { for (container_type::iterator i = iEntries.begin(); i != iEntries.end(); ++i) if (**i == aEntry) return false; iEntries.push_back(notify_entry_ptr(new notify_entry(aEntry))); if (!iLoading) notify_observers(notify_list_observer::NotifyAdded, *iEntries.back()); return true; }
void notify::remove(const notify_entry& aEntry) { for (container_type::iterator i = iEntries.begin(); i != iEntries.end(); ++i) if (&**i == &aEntry) { notify_entry_ptr temp = *i; iEntries.erase(i); notify_observers(notify_list_observer::NotifyRemoved, *temp); break; } }
void netlink_wrapper::link_cache_callback(nl_cache* , nl_object* obj, int) { nl_logfunc( "---> link_cache_callback"); struct rtnl_link* link = (struct rtnl_link*) obj; link_nl_event new_event(g_nl_rcv_arg.msghdr, link, g_nl_rcv_arg.netlink); notify_observers(&new_event, nlgrpLINK); g_nl_rcv_arg.msghdr = NULL; nl_logfunc( "<--- link_cache_callback"); }
void Player::step() { if(energy < 0) kill(); if(energy < 100 && energy_timer.GetElapsedTime() > charge_rate) { energy++; energy_timer.Reset(); } notify_observers(); }
void netlink_wrapper::neigh_cache_callback(nl_cache* , nl_object* obj, int) { nl_logfunc( "---> neigh_cache_callback"); struct rtnl_neigh* neigh = (struct rtnl_neigh*)obj; neigh_nl_event new_event(g_nl_rcv_arg.msghdr, neigh, g_nl_rcv_arg.netlink); notify_observers(&new_event, nlgrpNEIGH); g_nl_rcv_arg.msghdr = NULL; nl_logfunc( "<--- neigh_cache_callback"); }
virtual void apply_changes() { if (!dirty()) return; std::set<string> categoriesChanged; for (setting_list::iterator iter = iSettings.begin(); iter != iSettings.end(); ++iter) if (iter->apply_change()) categoriesChanged.insert(iter->category()); for (std::set<string>::const_iterator iter = categoriesChanged.begin(); iter != categoriesChanged.end(); ++iter) notify_observers(i_subscriber::NotifySettingsChanged, *iter); save(); }
void Docs::remove(Doc* doc) { iterator it = std::find(begin(), end(), doc); if (it == end()) // Already removed. return; m_docs.erase(it); notify_observers(&DocsObserver::onRemoveDocument, doc); doc->setContext(NULL); }
bool StoredEnvironment::set_value( const std::string& name, const std::string& value ) { for(unsigned int i=0; i<environments_.size(); i++) { if(environments_[i]->set_value(name,value)) { return true ; } } values_[name] = value ; notify_observers(name) ; return true ; }
void unbound (const unbound_t result) { switch (result) { case BIND_KEY_DNE_RESULT: // System is incorrect. assert (false); break; case UNBOUND_RESULT: m_state = UNBOUND; notify_observers (); delete this; } }
void route_entry::notify_cb() { // got addr_change event from net_device_entry --> does not change the validity of route_entry! rt_entry_logdbg(""); if (m_p_net_dev_entry->is_valid()) { m_p_net_dev_entry->get_val(m_p_net_dev_val); } else { m_p_net_dev_val = NULL; } notify_observers(); }
bool Graph::add_vertex(const Vertex *vertex) { const std::string F("add_vertex"); // null vertices not allowed if (vertex == nullptr) { notify_observers( Message(MsgID::WARNING, F, "null vertex is unsupported") ); return false; } _writer_lock(); // duplicate verticies not allowed if (!_vertices.insert(vertex).second) { notify_observers( Message(MsgID::WARNING, F, "vertex " + vertex->get_name() + " already added") ); _writer_unlock(); return false; } // each vertex holds two sets. one for all directed edges and the other for // the purpose of finding indegree. _directed_edges.insert(std::make_pair(vertex, new VertexSet)); _reverse_edges.insert(std::make_pair(vertex, new VertexSet)); notify_observers( Message(MsgID::INFO, F, "vertex " + vertex->get_name() + " added") ); _writer_unlock(); return true; }
Doc* Docs::add(Doc* doc) { ASSERT(doc != NULL); ASSERT(doc->id() != doc::NullId); if (doc->context() != m_ctx) { doc->setContext(m_ctx); ASSERT(std::find(begin(), end(), doc) != end()); return doc; } m_docs.insert(begin(), doc); notify_observers(&DocsObserver::onAddDocument, doc); return doc; }
void unbound (const ioa::unbound_t result) { switch (result) { case ioa::BIND_KEY_DNE_RESULT: assert (false); break; case ioa::UNBOUND_RESULT: // Okay. m_bound = false; ++m_unbound_count; notify_observers (); if (m_unbound_count == 2) { delete this; } break; } }
void netlink_wrapper::route_cache_callback(nl_cache* , nl_object* obj, int) { nl_logfunc( "---> route_cache_callback"); struct rtnl_route* route = (struct rtnl_route*) obj; route_nl_event new_event(g_nl_rcv_arg.msghdr, route,g_nl_rcv_arg.netlink); // notify only route events of main table const netlink_route_info* info = new_event.get_route_info(); if (info->table == ROUTE_MAIN_TABLE_ID) { notify_observers(&new_event, nlgrpROUTE); } else { nl_logfunc("ROUTE events from non-main route table are filtered: table_id=%d", info->table); } g_nl_rcv_arg.msghdr = NULL; nl_logfunc( "<--- route_cache_callback"); }
Doc* Docs::add(int width, int height, ColorMode mode, int ncolors) { // Ask to observers to create the document (maybe a doc::Document or // a derived class). CreateDocArgs args; notify_observers(&DocsObserver::onCreateDocument, &args); if (!args.document()) args.setDocument(new Doc(nullptr)); std::unique_ptr<Doc> doc(args.document()); doc->sprites().add(width, height, mode, ncolors); doc->setFilename("Sprite"); doc->setContext(m_ctx); // Change the document context to add the doc in this collection return doc.release(); }
Graph::size_type Graph::outdegree(const Vertex *vertex) const { _reader_lock(); const std::string F("outdegree"); if (_vertices.find(vertex) == _vertices.cend()) { notify_observers(Message( MsgID::ERROR, F, "vertex " + vertex->get_name() + " does not exist in graph") ); _reader_unlock(); return 0; } size_type size = _directed_edges.find(vertex)->second->size(); _reader_unlock(); return size; }
void bound (const bound_t result) { switch (result) { case BIND_KEY_EXISTS_RESULT: // System is incorrect. assert (false); break; case OUTPUT_AUTOMATON_DNE_RESULT: m_state = OUTPUT_AUTOMATON_DNE; notify_observers (); delete this; break; case INPUT_AUTOMATON_DNE_RESULT: m_state = INPUT_AUTOMATON_DNE; notify_observers (); delete this; break; case BINDING_EXISTS_RESULT: m_state = BINDING_EXISTS; notify_observers (); delete this; break; case INPUT_ACTION_UNAVAILABLE_RESULT: m_state = INPUT_ACTION_UNAVAILABLE; notify_observers (); delete this; break; case OUTPUT_ACTION_UNAVAILABLE_RESULT: m_state = OUTPUT_ACTION_UNAVAILABLE; notify_observers (); delete this; break; case BOUND: m_state = BOUND; notify_observers (); break; } }
//********************************* // Notify all of the observers. //********************************* void send_notifications() { notify_observers(data1); notify_observers(data2); }
//********************************* // Notify all of the observers. //********************************* void send_notifications() { notify_observers(data3); }
void notify_observers(notify_type aType, const T1& aParameter, const T2& aParameter2) { notify_observers(aType, static_cast<const void*>(&aParameter), static_cast<const void*>(&aParameter2)); }
void notify_observers(notify_type aType, const T& aParameter) const { notify_observers(aType, static_cast<const void*>(&aParameter)); }