自学教程：C++ unsubscribe函数代码示例

/********************************************************************* * * Main Program.  Open and subscribe for events for two sessions. * Then run the above test. * * *******************************************************************/int main(){	int ret = SAF_TEST_UNRESOLVED;	SaHpiSessionIdT sessionId1;	SaHpiSessionIdT sessionId2;	if (openSession(&sessionId1) != SA_OK) {		ret = SAF_TEST_UNRESOLVED;	} else {		if (openSession(&sessionId2) != SA_OK) {			ret = SAF_TEST_UNRESOLVED;		} else {			if (subscribe(sessionId1) != SA_OK) {				ret = SAF_TEST_UNRESOLVED;			} else {				if (subscribe(sessionId2) != SA_OK) {					ret = SAF_TEST_UNRESOLVED;				} else {					ret = run_test(sessionId1, sessionId2);					unsubscribe(sessionId2);				}				unsubscribe(sessionId1);			}			closeSession(sessionId2);		}		closeSession(sessionId1);	}	return ret;}

//=================== DESTROYER =============================StatisticsCollector::~StatisticsCollector() {    if(isSubscribed("arrival",listener)){        unsubscribe("arrival", listener);    }    if(isSubscribed("arrivalTime",listener)){        unsubscribe("arrivalTime", listener);    }}

 void ConnectionBasedNodelet::connectionCallback(const ros::SingleSubscriberPublisher& pub) {   if (verbose_connection_) {     JSK_NODELET_INFO("New connection or disconnection is detected");   }   if (!always_subscribe_) {     boost::mutex::scoped_lock lock(connection_mutex_);     for (size_t i = 0; i < publishers_.size(); i++) {       ros::Publisher pub = publishers_[i];       if (pub.getNumSubscribers() > 0) {         if (!ever_subscribed_) {           ever_subscribed_ = true;         }         if (connection_status_ != SUBSCRIBED) {           if (verbose_connection_) {             JSK_NODELET_INFO("Subscribe input topics");           }           subscribe();           connection_status_ = SUBSCRIBED;         }         return;       }     }     if (connection_status_ == SUBSCRIBED) {       if (verbose_connection_) {         JSK_NODELET_INFO("Unsubscribe input topics");       }       unsubscribe();       connection_status_ = NOT_SUBSCRIBED;     }   } }

void InteractiveMarkerDisplay::updatePoses(    const std::string& server_id,    const std::vector<visualization_msgs::InteractiveMarkerPose>& marker_poses ){  M_StringToIMPtr& im_map = getImMap( server_id );  for ( size_t i=0; i<marker_poses.size(); i++ )  {    const visualization_msgs::InteractiveMarkerPose& marker_pose = marker_poses[i];    if ( !validateFloats( marker_pose.pose ) )    {      setStatusStd( StatusProperty::Error, marker_pose.name, "Pose message contains invalid floats!" );      return;    }    std::map< std::string, IMPtr >::iterator int_marker_entry = im_map.find( marker_pose.name );    if ( int_marker_entry != im_map.end() )    {      int_marker_entry->second->processMessage( marker_pose );    }    else    {      setStatusStd( StatusProperty::Error, marker_pose.name, "Pose received for non-existing marker '" + marker_pose.name );      unsubscribe();      return;    }  }}

NXTColorDisplay::~NXTColorDisplay(){  unsubscribe();  clear();  delete cylinder_;  delete tf_filter_;}

bool PubSubClient::unsubscribe(String topic) {  if (!connected())    return false;  MQTT::Unsubscribe unsub(topic);  return unsubscribe(unsub);}

	void unsubscribe(InputIterator const& topics_begin, InputIterator const& topics_end)	{		for(InputIterator it = topics_begin; it != topics_end; ++it)		{			unsubscribe(*it);		}	}

 void msg_disconnectCb(const ros::SingleSubscriberPublisher&) {   subscriber_count_--;   if (subscriber_count_ == 0) {     unsubscribe();   } }

NfcSender::~NfcSender(){    nfc_unregister_snep_client();    nfc_stop_events();    unsubscribe(nfc_get_domain());    bps_shutdown();}

static void sub_endpoint_update_handler(void *data,	struct stasis_subscription *sub,	struct stasis_message *message){	RAII_VAR(struct ast_json *, json, NULL, ast_json_unref);	struct stasis_app *app = data;	struct stasis_cache_update *update;	struct ast_endpoint_snapshot *new_snapshot;	struct ast_endpoint_snapshot *old_snapshot;	const struct timeval *tv;	ast_assert(stasis_message_type(message) == stasis_cache_update_type());	update = stasis_message_data(message);	ast_assert(update->type == ast_endpoint_snapshot_type());	new_snapshot = stasis_message_data(update->new_snapshot);	old_snapshot = stasis_message_data(update->old_snapshot);	if (new_snapshot) {		tv = stasis_message_timestamp(update->new_snapshot);		json = simple_endpoint_event("EndpointStateChange", new_snapshot, tv);		if (!json) {			return;		}		app_send(app, json);	}	if (!new_snapshot && old_snapshot) {		unsubscribe(app, "endpoint", old_snapshot->id, 1);	}}

void PointCloud2Display::onDisable(){  unsubscribe();  tf_filter_.clear();  PointCloudBase::onDisable();}

		void stress_subscriber::next_action_impl()		{			if ( !remaining_actions_ )				return;			--remaining_actions_;			const boost::int32_t rand = random( 1, 100 );			if ( rand < 30 )			{				subscribe();			}			else if ( rand < 60 )			{			    unsubscribe();			}			else if ( rand < 90 )			{				change();			}			else			{				change_configuration();			}		}

/*! /brief Function called when a contact is added */static void mwi_contact_added(const void *object){	const struct ast_sip_contact *contact = object;	struct ao2_iterator *mwi_subs;	struct mwi_subscription *mwi_sub;	const char *endpoint_id = ast_sorcery_object_get_id(contact->endpoint);	if (ast_strlen_zero(contact->endpoint->subscription.mwi.mailboxes)) {		return;	}	ao2_lock(unsolicited_mwi);	mwi_subs = ao2_find(unsolicited_mwi, endpoint_id, OBJ_SEARCH_KEY | OBJ_MULTIPLE | OBJ_NOLOCK | OBJ_UNLINK);	if (mwi_subs) {		for (; (mwi_sub = ao2_iterator_next(mwi_subs)); ao2_cleanup(mwi_sub)) {			unsubscribe(mwi_sub, NULL, 0);		}		ao2_iterator_destroy(mwi_subs);	}	create_mwi_subscriptions_for_endpoint(contact->endpoint, NULL, 0);	ao2_unlock(unsolicited_mwi);	mwi_contact_updated(object);}

void StereoImageDisplayBase::updateTopics(){  unsubscribe();  reset();  subscribe();  context_->queueRender();}

void DepthCloudDisplay::updateTopic(){  unsubscribe();  reset();  subscribe();  context_->queueRender();}

void PointCloudDisplay::onDisable(){  unsubscribe();  cloud_->clear();  cloud_->setCloudVisible( false );}

 void OverlayMenuDisplay::onDisable() {   if (overlay_) {     overlay_->hide();   }   unsubscribe(); }

void MarkerDisplay::onDisable(){  unsubscribe();  tf_filter_->clear();  clearMarkers();}

	void LuaSystem::onDetach(Entity &entity)	{		// Iterate subscriptions		LuaComponent *comp = entity.getComponent<LuaComponent>();		for(auto eventItr = comp->subscribedEvents.begin(); eventItr != comp->subscribedEvents.end(); eventItr++)		{			auto itr = m_subscribedScripts.find(*eventItr);			if(itr == m_subscribedScripts.end())				continue;			// Iterate entities associated with subscriptions			for(std::size_t i = 0; i < itr->second.size(); i++)			{				// Unsubscribe entity if found				if(itr->second[i] == &entity)				{					itr->second.erase(itr->second.begin() + i);					// Unsubscribe from it entirely if none wants it, except the Reload event					if(itr->first != "ReloadLua" && itr->second.empty())					{						unsubscribe(itr->first);						m_subscribedScripts.erase(itr);					}					break;				}			}		}	}

MacAddressHandler::~MacAddressHandler(){    nfc_unregister_handover_listener();    nfc_stop_events();    unsubscribe(nfc_get_domain());    bps_shutdown();}

void TrackDisplay::setTopic(const std::string& topic) {	unsubscribe();	track_topic_ = topic;	subscribe();	propertyChanged(topic_property_);}

 void disconnectCb(const image_transport::SingleSubscriberPublisher&) {     subscriber_count_--;     if (subscriber_count_ == 0) {         unsubscribe();     } }

RobotModelDisplay::~RobotModelDisplay(){  unsubscribe();  delete robot_;  delete urdf_;}

CameraDisplay::~CameraDisplay(){  unsubscribe();  caminfo_tf_filter_->clear();  if( render_panel_ )  {    if( panel_container_ )    {      delete panel_container_;    }    else    {      delete render_panel_;    }  }  delete bg_screen_rect_;  delete fg_screen_rect_;  bg_scene_node_->getParentSceneNode()->removeAndDestroyChild( bg_scene_node_->getName() );  fg_scene_node_->getParentSceneNode()->removeAndDestroyChild( fg_scene_node_->getName() );  delete caminfo_tf_filter_;}

static void sub_bridge_update_handler(void *data,	struct stasis_subscription *sub,	struct stasis_message *message){	struct ast_json *json = NULL;	struct stasis_app *app = data;	struct ast_bridge_snapshot_update *update;	const struct timeval *tv;	update = stasis_message_data(message);	tv = stasis_message_timestamp(message);	if (!update->new_snapshot) {		json = simple_bridge_event("BridgeDestroyed", update->old_snapshot, tv);	} else if (!update->old_snapshot) {		json = simple_bridge_event("BridgeCreated", update->new_snapshot, tv);	} else if (update->new_snapshot && update->old_snapshot		&& strcmp(update->new_snapshot->video_source_id, update->old_snapshot->video_source_id)) {		json = simple_bridge_event("BridgeVideoSourceChanged", update->new_snapshot, tv);		if (json && !ast_strlen_zero(update->old_snapshot->video_source_id)) {			ast_json_object_set(json, "old_video_source_id",				ast_json_string_create(update->old_snapshot->video_source_id));		}	}	if (json) {		app_send(app, json);		ast_json_unref(json);	}	if (!update->new_snapshot && update->old_snapshot) {		unsubscribe(app, "bridge", update->old_snapshot->uniqueid, 1);	}}

    void on_link_close(proton::event &e) {        proton::link lnk = e.link();        if (!!lnk.sender()) {            unsubscribe(lnk.sender());        }    }

void CameraPub::updateTopic(){  unsubscribe();  reset();  subscribe();  context_->queueRender();}

 ~PhaseSpaceLocalization() {     unsubscribe("phase_space_snapshot") ;     unadvertise("localizedpose") ;     if (m_tfServer)         delete m_tfServer; }