OpenDDS::DCPS::EndpointManager

OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ > Class Template Reference

#include <DiscoveryBase.h>

Inheritance diagram for OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >:

Inheritance graph
[legend]
Collaboration diagram for OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >:

Collaboration graph
[legend]
List of all members.

Public Types

typedef DiscoveredParticipantData_ DiscoveredParticipantData

Public Member Functions

 EndpointManager (const RepoId &participant_id, ACE_Thread_Mutex &lock)
virtual ~EndpointManager ()
RepoId bit_key_to_repo_id (const char *bit_topic_name, const DDS::BuiltinTopicKey_t &key)
void ignore (const DCPS::RepoId &to_ignore)
bool ignoring (const DCPS::RepoId &guid) const
bool ignoring (const char *topic_name) const
DCPS::TopicStatus assert_topic (DCPS::RepoId_out topicId, const char *topicName, const char *dataTypeName, const DDS::TopicQos &qos, bool hasDcpsKey)
DCPS::TopicStatus remove_topic (const RepoId &topicId, OPENDDS_STRING &name)
virtual bool update_topic_qos (const DCPS::RepoId &topicId, const DDS::TopicQos &qos, OPENDDS_STRING &name)=0
DCPS::RepoId add_publication (const DCPS::RepoId &topicId, DCPS::DataWriterCallbacks *publication, const DDS::DataWriterQos &qos, const DCPS::TransportLocatorSeq &transInfo, const DDS::PublisherQos &publisherQos)
void remove_publication (const DCPS::RepoId &publicationId)
virtual bool update_publication_qos (const DCPS::RepoId &publicationId, const DDS::DataWriterQos &qos, const DDS::PublisherQos &publisherQos)=0
DCPS::RepoId add_subscription (const DCPS::RepoId &topicId, DCPS::DataReaderCallbacks *subscription, const DDS::DataReaderQos &qos, const DCPS::TransportLocatorSeq &transInfo, const DDS::SubscriberQos &subscriberQos, const char *filterClassName, const char *filterExpr, const DDS::StringSeq &params)
void remove_subscription (const DCPS::RepoId &subscriptionId)
virtual bool update_subscription_qos (const DCPS::RepoId &subscriptionId, const DDS::DataReaderQos &qos, const DDS::SubscriberQos &subscriberQos)=0
virtual bool update_subscription_params (const DCPS::RepoId &subId, const DDS::StringSeq &params)=0
virtual void association_complete (const DCPS::RepoId &localId, const DCPS::RepoId &remoteId)=0
virtual bool disassociate (const DiscoveredParticipantData &pdata)=0

Protected Types

typedef DiscoveredSubscriptionMap::iterator DiscoveredSubscriptionIter
typedef DiscoveredPublicationMap::iterator DiscoveredPublicationIter
typedef LocalPublicationMap::iterator LocalPublicationIter
typedef LocalPublicationMap::const_iterator LocalPublicationCIter
typedef LocalSubscriptionMap::iterator LocalSubscriptionIter
typedef LocalSubscriptionMap::const_iterator LocalSubscriptionCIter

Protected Member Functions

typedef OPENDDS_MAP_CMP (DCPS::RepoId, DiscoveredSubscription, DCPS::GUID_tKeyLessThan) DiscoveredSubscriptionMap
typedef OPENDDS_MAP_CMP (DCPS::RepoId, DiscoveredPublication, DCPS::GUID_tKeyLessThan) DiscoveredPublicationMap
typedef OPENDDS_MAP_CMP (DDS::BuiltinTopicKey_t, DCPS::RepoId, DCPS::BuiltinTopicKeyLess) BitKeyMap
typedef OPENDDS_MAP_CMP (DCPS::RepoId, LocalPublication, DCPS::GUID_tKeyLessThan) LocalPublicationMap
typedef OPENDDS_MAP_CMP (DCPS::RepoId, LocalSubscription, DCPS::GUID_tKeyLessThan) LocalSubscriptionMap
typedef OPENDDS_MAP_CMP (DCPS::RepoId, OPENDDS_STRING, DCPS::GUID_tKeyLessThan) TopicNameMap
virtual void remove_from_bit_i (const DiscoveredPublication &)
virtual void remove_from_bit_i (const DiscoveredSubscription &)
virtual void assign_publication_key (RepoId &rid, const RepoId &topicId, const DDS::DataWriterQos &)
virtual void assign_subscription_key (RepoId &rid, const RepoId &topicId, const DDS::DataReaderQos &)
virtual void assign_topic_key (RepoId &guid)
virtual DDS::ReturnCode_t add_publication_i (const DCPS::RepoId &, LocalPublication &)
virtual DDS::ReturnCode_t write_publication_data (const DCPS::RepoId &, LocalPublication &, const DCPS::RepoId &reader=DCPS::GUID_UNKNOWN)
virtual DDS::ReturnCode_t remove_publication_i (const RepoId &publicationId)=0
virtual DDS::ReturnCode_t add_subscription_i (const DCPS::RepoId &, LocalSubscription &)
virtual DDS::ReturnCode_t write_subscription_data (const DCPS::RepoId &, LocalSubscription &, const DCPS::RepoId &reader=DCPS::GUID_UNKNOWN)
virtual DDS::ReturnCode_t remove_subscription_i (const RepoId &subscriptionId)=0
void match_endpoints (DCPS::RepoId repoId, const TopicDetails &td, bool remove=false)
void remove_assoc (const RepoId &remove_from, const RepoId &removing)
void match (const RepoId &writer, const RepoId &reader)
virtual bool shutting_down () const =0
virtual void populate_transport_locator_sequence (DCPS::TransportLocatorSeq *&tls, DiscoveredSubscriptionIter &iter, const RepoId &reader)=0
virtual void populate_transport_locator_sequence (DCPS::TransportLocatorSeq *&tls, DiscoveredPublicationIter &iter, const RepoId &reader)=0
virtual bool defer_writer (const RepoId &writer, const RepoId &writer_participant)=0
virtual bool defer_reader (const RepoId &writer, const RepoId &writer_participant)=0
void remove_from_bit (const DiscoveredPublication &pub)
void remove_from_bit (const DiscoveredSubscription &sub)
RepoId make_topic_guid ()
bool has_dcps_key (const DCPS::RepoId &topicId) const
void increment_key (DDS::BuiltinTopicKey_t &key)
 OPENDDS_MAP (OPENDDS_STRING, TopicDetails) topics_
 OPENDDS_SET (OPENDDS_STRING) ignored_topics_

Static Protected Member Functions

static const char * get_topic_name (const DiscoveredPublication &pub)
static const char * get_topic_name (const DiscoveredSubscription &sub)
static DDS::BuiltinTopicKey_t get_key (const DiscoveredPublication &pub)
static DDS::BuiltinTopicKey_t get_key (const DiscoveredSubscription &sub)
static bool is_opendds (const GUID_t &endpoint)

Protected Attributes

ACE_Thread_Mutex & lock_
DCPS::RepoId participant_id_
BitKeyMap pub_key_to_id_
BitKeyMap sub_key_to_id_
RepoIdSet ignored_guids_
unsigned int publication_counter_
unsigned int subscription_counter_
unsigned int topic_counter_
LocalPublicationMap local_publications_
LocalSubscriptionMap local_subscriptions_
DiscoveredPublicationMap discovered_publications_
DiscoveredSubscriptionMap discovered_subscriptions_
TopicNameMap topic_names_
DDS::BuiltinTopicKey_t pub_bit_key_
DDS::BuiltinTopicKey_t sub_bit_key_

Classes

struct  DiscoveredPublication
struct  DiscoveredSubscription
struct  LocalEndpoint
struct  LocalPublication
struct  LocalSubscription
struct  TopicDetails

Detailed Description

template<typename DiscoveredParticipantData_>
class OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >

Definition at line 80 of file DiscoveryBase.h.

Member Typedef Documentation

template<typename DiscoveredParticipantData_>
typedef DiscoveredParticipantData_ OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::DiscoveredParticipantData

Definition at line 106 of file DiscoveryBase.h.

template<typename DiscoveredParticipantData_>
typedef DiscoveredPublicationMap::iterator OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::DiscoveredPublicationIter [protected]

Definition at line 103 of file DiscoveryBase.h.

template<typename DiscoveredParticipantData_>
typedef DiscoveredSubscriptionMap::iterator OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::DiscoveredSubscriptionIter [protected]

Definition at line 91 of file DiscoveryBase.h.

template<typename DiscoveredParticipantData_>
typedef LocalPublicationMap::const_iterator OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::LocalPublicationCIter [protected]

Definition at line 420 of file DiscoveryBase.h.

template<typename DiscoveredParticipantData_>
typedef LocalPublicationMap::iterator OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::LocalPublicationIter [protected]

Definition at line 419 of file DiscoveryBase.h.

template<typename DiscoveredParticipantData_>
typedef LocalSubscriptionMap::const_iterator OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::LocalSubscriptionCIter [protected]

Definition at line 425 of file DiscoveryBase.h.

template<typename DiscoveredParticipantData_>
typedef LocalSubscriptionMap::iterator OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::LocalSubscriptionIter [protected]

Definition at line 424 of file DiscoveryBase.h.

Constructor & Destructor Documentation

template<typename DiscoveredParticipantData_>
OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::EndpointManager ( const RepoId &  participant_id,
ACE_Thread_Mutex &  lock 
) [inline]

Definition at line 116 of file DiscoveryBase.h.

00117         : lock_(lock)
00118         , participant_id_(participant_id)
00119         , publication_counter_(0)
00120         , subscription_counter_(0)
00121         , topic_counter_(0)
00122       { }

template<typename DiscoveredParticipantData_>
virtual OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::~EndpointManager (  )  [inline, virtual]

Definition at line 124 of file DiscoveryBase.h.

00124 { }

Member Function Documentation

template<typename DiscoveredParticipantData_>
DCPS::RepoId OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::add_publication ( const DCPS::RepoId &  topicId,
DCPS::DataWriterCallbacks *  publication,
const DDS::DataWriterQos &  qos,
const DCPS::TransportLocatorSeq &  transInfo,
const DDS::PublisherQos &  publisherQos 
) [inline]

Definition at line 252 of file DiscoveryBase.h.

00257       {
00258         ACE_GUARD_RETURN(ACE_Thread_Mutex, g, lock_, RepoId());
00259         RepoId rid = participant_id_;
00260         assign_publication_key(rid, topicId, qos);
00261         LocalPublication& pb = local_publications_[rid];
00262         pb.topic_id_ = topicId;
00263         pb.publication_ = publication;
00264         pb.qos_ = qos;
00265         pb.trans_info_ = transInfo;
00266         pb.publisher_qos_ = publisherQos;
00267         TopicDetails& td = topics_[topic_names_[topicId]];
00268         td.endpoints_.insert(rid);
00269 
00270         if (DDS::RETCODE_OK != add_publication_i(rid, pb)) {
00271           return RepoId();
00272         }
00273 
00274         if (DDS::RETCODE_OK != write_publication_data(rid, pb)) {
00275           return RepoId();
00276         }
00277 
00278         if (DCPS::DCPS_debug_level > 3) {
00279           ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) EndpointManager::add_publication - ")
00280                      ACE_TEXT("calling match_endpoints\n")));
00281         }
00282         match_endpoints(rid, td);
00283 
00284         return rid;
00285       }

template<typename DiscoveredParticipantData_>
virtual DDS::ReturnCode_t OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::add_publication_i ( const DCPS::RepoId &  ,
LocalPublication &   
) [inline, protected, virtual]

Definition at line 475 of file DiscoveryBase.h.

Referenced by OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::add_publication().

00476                                                                              { return DDS::RETCODE_OK; }

template<typename DiscoveredParticipantData_>
DCPS::RepoId OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::add_subscription ( const DCPS::RepoId &  topicId,
DCPS::DataReaderCallbacks *  subscription,
const DDS::DataReaderQos &  qos,
const DCPS::TransportLocatorSeq &  transInfo,
const DDS::SubscriberQos &  subscriberQos,
const char *  filterClassName,
const char *  filterExpr,
const DDS::StringSeq &  params 
) [inline]

Definition at line 314 of file DiscoveryBase.h.

00322       {
00323         ACE_GUARD_RETURN(ACE_Thread_Mutex, g, lock_, RepoId());
00324         RepoId rid = participant_id_;
00325         assign_subscription_key(rid, topicId, qos);
00326         LocalSubscription& sb = local_subscriptions_[rid];
00327         sb.topic_id_ = topicId;
00328         sb.subscription_ = subscription;
00329         sb.qos_ = qos;
00330         sb.trans_info_ = transInfo;
00331         sb.subscriber_qos_ = subscriberQos;
00332         sb.filterProperties.filterClassName = filterClassName;
00333         sb.filterProperties.filterExpression = filterExpr;
00334         sb.filterProperties.expressionParameters = params;
00335 
00336         TopicDetails& td = topics_[topic_names_[topicId]];
00337         td.endpoints_.insert(rid);
00338 
00339         if (DDS::RETCODE_OK != add_subscription_i(rid, sb)) {
00340           return RepoId();
00341         }
00342 
00343         if (DDS::RETCODE_OK != write_subscription_data(rid, sb)) {
00344           return RepoId();
00345         }
00346 
00347         if (DCPS::DCPS_debug_level > 3) {
00348           ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) EndpointManager::add_subscription - ")
00349                      ACE_TEXT("calling match_endpoints\n")));
00350         }
00351         match_endpoints(rid, td);
00352 
00353         return rid;
00354       }

template<typename DiscoveredParticipantData_>
virtual DDS::ReturnCode_t OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::add_subscription_i ( const DCPS::RepoId &  ,
LocalSubscription &   
) [inline, protected, virtual]

Definition at line 482 of file DiscoveryBase.h.

Referenced by OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::add_subscription().

00483                                                                                { return DDS::RETCODE_OK; };

template<typename DiscoveredParticipantData_>
DCPS::TopicStatus OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::assert_topic ( DCPS::RepoId_out  topicId,
const char *  topicName,
const char *  dataTypeName,
const DDS::TopicQos &  qos,
bool  hasDcpsKey 
) [inline]

Definition at line 206 of file DiscoveryBase.h.

00209       {
00210         ACE_GUARD_RETURN(ACE_Thread_Mutex, g, lock_, DCPS::INTERNAL_ERROR);
00211         typename OPENDDS_MAP(OPENDDS_STRING, TopicDetails)::iterator iter =
00212           topics_.find(topicName);
00213         if (iter != topics_.end()) { // types must match, RtpsDiscovery checked for us
00214           iter->second.qos_ = qos;
00215           iter->second.has_dcps_key_ = hasDcpsKey;
00216           topicId = iter->second.repo_id_;
00217           topic_names_[iter->second.repo_id_] = topicName;
00218           return DCPS::FOUND;
00219         }
00220 
00221         TopicDetails& td = topics_[topicName];
00222         td.data_type_ = dataTypeName;
00223         td.qos_ = qos;
00224         td.has_dcps_key_ = hasDcpsKey;
00225         td.repo_id_ = make_topic_guid();
00226         topicId = td.repo_id_;
00227         topic_names_[td.repo_id_] = topicName;
00228 
00229         return DCPS::CREATED;
00230       }

template<typename DiscoveredParticipantData_>
virtual void OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::assign_publication_key ( RepoId &  rid,
const RepoId &  topicId,
const DDS::DataWriterQos &   
) [inline, protected, virtual]

Reimplemented in OpenDDS::DCPS::StaticEndpointManager.

Definition at line 445 of file DiscoveryBase.h.

Referenced by OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::add_publication().

00447                                                                            {
00448         rid.entityId.entityKind =
00449           has_dcps_key(topicId)
00450           ? DCPS::ENTITYKIND_USER_WRITER_WITH_KEY
00451           : DCPS::ENTITYKIND_USER_WRITER_NO_KEY;
00452         assign(rid.entityId.entityKey, publication_counter_++);
00453       }

template<typename DiscoveredParticipantData_>
virtual void OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::assign_subscription_key ( RepoId &  rid,
const RepoId &  topicId,
const DDS::DataReaderQos &   
) [inline, protected, virtual]

Reimplemented in OpenDDS::DCPS::StaticEndpointManager.

Definition at line 454 of file DiscoveryBase.h.

Referenced by OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::add_subscription().

00456                                                                             {
00457         rid.entityId.entityKind =
00458           has_dcps_key(topicId)
00459           ? DCPS::ENTITYKIND_USER_READER_WITH_KEY
00460           : DCPS::ENTITYKIND_USER_READER_NO_KEY;
00461         assign(rid.entityId.entityKey, subscription_counter_++);
00462       }

template<typename DiscoveredParticipantData_>
virtual void OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::assign_topic_key ( RepoId &  guid  )  [inline, protected, virtual]

Definition at line 463 of file DiscoveryBase.h.

Referenced by OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::make_topic_guid().

00463                                                   {
00464         assign(guid.entityId.entityKey, topic_counter_++);
00465 
00466         if (topic_counter_ == 0x1000000) {
00467           ACE_DEBUG((LM_ERROR,
00468                      ACE_TEXT("(%P|%t) ERROR: EndpointManager::make_topic_guid: ")
00469                      ACE_TEXT("Exceeded Maximum number of topic entity keys!")
00470                      ACE_TEXT("Next key will be a duplicate!\n")));
00471           topic_counter_ = 0;
00472         }
00473       }

template<typename DiscoveredParticipantData_>
virtual void OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::association_complete ( const DCPS::RepoId &  localId,
const DCPS::RepoId &  remoteId 
) [pure virtual]

Implemented in OpenDDS::RTPS::Sedp, and OpenDDS::DCPS::StaticEndpointManager.

template<typename DiscoveredParticipantData_>
RepoId OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::bit_key_to_repo_id ( const char *  bit_topic_name,
const DDS::BuiltinTopicKey_t &  key 
) [inline]

Definition at line 126 of file DiscoveryBase.h.

Referenced by OpenDDS::DCPS::PeerDiscovery< OpenDDS::DCPS::StaticParticipant >::bit_key_to_repo_id().

00128       {
00129         ACE_GUARD_RETURN(ACE_Thread_Mutex, g, lock_, RepoId());
00130         if (0 == std::strcmp(bit_topic_name, DCPS::BUILT_IN_PUBLICATION_TOPIC)) {
00131           return pub_key_to_id_[key];
00132         }
00133         if (0 == std::strcmp(bit_topic_name, DCPS::BUILT_IN_SUBSCRIPTION_TOPIC)) {
00134           return sub_key_to_id_[key];
00135         }
00136         return RepoId();
00137       }

template<typename DiscoveredParticipantData_>
virtual bool OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::defer_reader ( const RepoId &  writer,
const RepoId &  writer_participant 
) [protected, pure virtual]

Implemented in OpenDDS::RTPS::Sedp, and OpenDDS::DCPS::StaticEndpointManager.

Referenced by OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::match().

template<typename DiscoveredParticipantData_>
virtual bool OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::defer_writer ( const RepoId &  writer,
const RepoId &  writer_participant 
) [protected, pure virtual]

Implemented in OpenDDS::RTPS::Sedp, and OpenDDS::DCPS::StaticEndpointManager.

Referenced by OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::match().

template<typename DiscoveredParticipantData_>
virtual bool OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::disassociate ( const DiscoveredParticipantData &  pdata  )  [pure virtual]

template<typename DiscoveredParticipantData_>
static DDS::BuiltinTopicKey_t OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::get_key ( const DiscoveredSubscription &  sub  )  [inline, static, protected]

Definition at line 438 of file DiscoveryBase.h.

00438                                                                              {
00439         return sub.reader_data_.ddsSubscriptionData.key;
00440       }

template<typename DiscoveredParticipantData_>
static DDS::BuiltinTopicKey_t OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::get_key ( const DiscoveredPublication &  pub  )  [inline, static, protected]

Definition at line 435 of file DiscoveryBase.h.

Referenced by OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::remove_from_bit().

00435                                                                             {
00436         return pub.writer_data_.ddsPublicationData.key;
00437       }

template<typename DiscoveredParticipantData_>
static const char* OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::get_topic_name ( const DiscoveredSubscription &  sub  )  [inline, static, protected]

Definition at line 432 of file DiscoveryBase.h.

00432                                                                            {
00433         return sub.reader_data_.ddsSubscriptionData.topic_name;
00434       }

template<typename DiscoveredParticipantData_>
static const char* OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::get_topic_name ( const DiscoveredPublication &  pub  )  [inline, static, protected]

Definition at line 429 of file DiscoveryBase.h.

Referenced by OpenDDS::RTPS::Sedp::data_received(), OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::ignore(), and OpenDDS::RTPS::Sedp::remove_entities_belonging_to().

00429                                                                           {
00430         return pub.writer_data_.ddsPublicationData.topic_name;
00431       }

template<typename DiscoveredParticipantData_>
bool OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::has_dcps_key ( const DCPS::RepoId &  topicId  )  const [inline, protected]

Definition at line 866 of file DiscoveryBase.h.

Referenced by OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::assign_publication_key(), and OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::assign_subscription_key().

00867       {
00868         typedef OPENDDS_MAP_CMP(RepoId, OPENDDS_STRING, DCPS::GUID_tKeyLessThan) TNMap;
00869         TNMap::const_iterator tn = topic_names_.find(topicId);
00870         if (tn == topic_names_.end()) return false;
00871 
00872         typedef OPENDDS_MAP(OPENDDS_STRING, TopicDetails) TDMap;
00873         typename TDMap::const_iterator td = topics_.find(tn->second);
00874         if (td == topics_.end()) return false;
00875 
00876         return td->second.has_dcps_key_;
00877       }

template<typename DiscoveredParticipantData_>
void OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::ignore ( const DCPS::RepoId &  to_ignore  )  [inline]

Definition at line 139 of file DiscoveryBase.h.

00140       {
00141         // Locked prior to call from Spdp.
00142         ignored_guids_.insert(to_ignore);
00143         {
00144           const DiscoveredPublicationIter iter =
00145             discovered_publications_.find(to_ignore);
00146           if (iter != discovered_publications_.end()) {
00147             // clean up tracking info
00148             topics_[get_topic_name(iter->second)].endpoints_.erase(iter->first);
00149             remove_from_bit(iter->second);
00150             OPENDDS_STRING topic_name = get_topic_name(iter->second);
00151             discovered_publications_.erase(iter);
00152             // break associations
00153             typename OPENDDS_MAP(OPENDDS_STRING, TopicDetails)::iterator top_it =
00154               topics_.find(topic_name);
00155             if (top_it != topics_.end()) {
00156               match_endpoints(to_ignore, top_it->second, true /*remove*/);
00157             }
00158             return;
00159           }
00160         }
00161         {
00162           const DiscoveredSubscriptionIter iter =
00163             discovered_subscriptions_.find(to_ignore);
00164           if (iter != discovered_subscriptions_.end()) {
00165             // clean up tracking info
00166             topics_[get_topic_name(iter->second)].endpoints_.erase(iter->first);
00167             remove_from_bit(iter->second);
00168             OPENDDS_STRING topic_name = get_topic_name(iter->second);
00169             discovered_subscriptions_.erase(iter);
00170             // break associations
00171             typename OPENDDS_MAP(OPENDDS_STRING, TopicDetails)::iterator top_it =
00172               topics_.find(topic_name);
00173             if (top_it != topics_.end()) {
00174               match_endpoints(to_ignore, top_it->second, true /*remove*/);
00175             }
00176             return;
00177           }
00178         }
00179         {
00180           const OPENDDS_MAP_CMP(RepoId, OPENDDS_STRING, DCPS::GUID_tKeyLessThan)::iterator
00181             iter = topic_names_.find(to_ignore);
00182           if (iter != topic_names_.end()) {
00183             ignored_topics_.insert(iter->second);
00184             // Remove all publications and subscriptions on this topic
00185             typename OPENDDS_MAP(OPENDDS_STRING, TopicDetails)::iterator top_it =
00186               topics_.find(iter->second);
00187             if (top_it != topics_.end()) {
00188               TopicDetails& td = top_it->second;
00189               RepoIdSet::iterator ep;
00190               for (ep = td.endpoints_.begin(); ep!= td.endpoints_.end(); ++ep) {
00191                 match_endpoints(*ep, td, true /*remove*/);
00192                 if (shutting_down()) { return; }
00193               }
00194             }
00195           }
00196         }
00197       }

template<typename DiscoveredParticipantData_>
bool OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::ignoring ( const char *  topic_name  )  const [inline]

Definition at line 202 of file DiscoveryBase.h.

00202                                                   {
00203         return ignored_topics_.count(topic_name);
00204       }

template<typename DiscoveredParticipantData_>
bool OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::ignoring ( const DCPS::RepoId &  guid  )  const [inline]

Definition at line 199 of file DiscoveryBase.h.

Referenced by OpenDDS::RTPS::Spdp::data_received(), and OpenDDS::RTPS::Sedp::data_received().

00199                                                   {
00200         return ignored_guids_.count(guid);
00201       }

template<typename DiscoveredParticipantData_>
void OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::increment_key ( DDS::BuiltinTopicKey_t &  key  )  [inline, protected]

Definition at line 880 of file DiscoveryBase.h.

Referenced by OpenDDS::RTPS::Sedp::assign_bit_key(), and OpenDDS::DCPS::StaticEndpointManager::init_bit().

00881       {
00882         for (int idx = 0; idx < 3; ++idx) {
00883           CORBA::ULong ukey = static_cast<CORBA::ULong>(key.value[idx]);
00884           if (ukey == 0xFFFFFFFF) {
00885             key.value[idx] = 0;
00886           } else {
00887             ++ukey;
00888             key.value[idx] = ukey;
00889             return;
00890           }
00891         }
00892         ACE_DEBUG((LM_WARNING, ACE_TEXT("(%P|%t) EndpointManager::increment_key - ")
00893                    ACE_TEXT("ran out of builtin topic keys\n")));
00894       }

template<typename DiscoveredParticipantData_>
static bool OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::is_opendds ( const GUID_t &  endpoint  )  [inline, static, protected]

Definition at line 823 of file DiscoveryBase.h.

Referenced by OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::match().

00824       {
00825         return !std::memcmp(endpoint.guidPrefix, DCPS::VENDORID_OCI,
00826                             sizeof(DCPS::VENDORID_OCI));
00827       }

template<typename DiscoveredParticipantData_>
RepoId OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::make_topic_guid (  )  [inline, protected]

Definition at line 857 of file DiscoveryBase.h.

Referenced by OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::assert_topic(), and OpenDDS::RTPS::Sedp::data_received().

00858       {
00859         RepoId guid;
00860         guid = participant_id_;
00861         guid.entityId.entityKind = DCPS::ENTITYKIND_OPENDDS_TOPIC;
00862         assign_topic_key(guid);
00863         return guid;
00864       }

template<typename DiscoveredParticipantData_>
void OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::match ( const RepoId &  writer,
const RepoId &  reader 
) [inline, protected]

Definition at line 543 of file DiscoveryBase.h.

Referenced by OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::match_endpoints().

00544       {
00545         // 0. For discovered endpoints, we'll have the QoS info in the form of the
00546         // publication or subscription BIT data which doesn't use the same structures
00547         // for QoS.  In those cases we can copy the individual QoS policies to temp
00548         // QoS structs:
00549         DDS::DataWriterQos tempDwQos;
00550         DDS::PublisherQos tempPubQos;
00551         DDS::DataReaderQos tempDrQos;
00552         DDS::SubscriberQos tempSubQos;
00553         ContentFilterProperty_t tempCfp;
00554 
00555         // 1. collect details about the writer, which may be local or discovered
00556         const DDS::DataWriterQos* dwQos = 0;
00557         const DDS::PublisherQos* pubQos = 0;
00558         DCPS::TransportLocatorSeq* wTls = 0;
00559 
00560         const LocalPublicationIter lpi = local_publications_.find(writer);
00561         DiscoveredPublicationIter dpi;
00562         bool writer_local = false, already_matched = false;
00563         if (lpi != local_publications_.end()) {
00564           writer_local = true;
00565           dwQos = &lpi->second.qos_;
00566           pubQos = &lpi->second.publisher_qos_;
00567           wTls = &lpi->second.trans_info_;
00568           already_matched = lpi->second.matched_endpoints_.count(reader);
00569         } else if ((dpi = discovered_publications_.find(writer))
00570                    != discovered_publications_.end()) {
00571           wTls = &dpi->second.writer_data_.writerProxy.allLocators;
00572         } else {
00573           return; // Possible and ok, since lock is released
00574         }
00575 
00576         // 2. collect details about the reader, which may be local or discovered
00577         const DDS::DataReaderQos* drQos = 0;
00578         const DDS::SubscriberQos* subQos = 0;
00579         DCPS::TransportLocatorSeq* rTls = 0;
00580         const ContentFilterProperty_t* cfProp = 0;
00581 
00582         const LocalSubscriptionIter lsi = local_subscriptions_.find(reader);
00583         DiscoveredSubscriptionIter dsi;
00584         bool reader_local = false;
00585         if (lsi != local_subscriptions_.end()) {
00586           reader_local = true;
00587           drQos = &lsi->second.qos_;
00588           subQos = &lsi->second.subscriber_qos_;
00589           rTls = &lsi->second.trans_info_;
00590           if (lsi->second.filterProperties.filterExpression[0] != 0) {
00591             tempCfp.filterExpression = lsi->second.filterProperties.filterExpression;
00592             tempCfp.expressionParameters = lsi->second.filterProperties.expressionParameters;
00593           }
00594           cfProp = &tempCfp;
00595           if (!already_matched) {
00596             already_matched = lsi->second.matched_endpoints_.count(writer);
00597           }
00598         } else if ((dsi = discovered_subscriptions_.find(reader))
00599                    != discovered_subscriptions_.end()) {
00600           if (!writer_local) {
00601             // this is a discovered/discovered match, nothing for us to do
00602             return;
00603           }
00604           rTls = &dsi->second.reader_data_.readerProxy.allLocators;
00605 
00606           populate_transport_locator_sequence(rTls, dsi, reader);
00607 
00608           const DDS::SubscriptionBuiltinTopicData& bit =
00609             dsi->second.reader_data_.ddsSubscriptionData;
00610           tempDrQos.durability = bit.durability;
00611           tempDrQos.deadline = bit.deadline;
00612           tempDrQos.latency_budget = bit.latency_budget;
00613           tempDrQos.liveliness = bit.liveliness;
00614           tempDrQos.reliability = bit.reliability;
00615           tempDrQos.destination_order = bit.destination_order;
00616           tempDrQos.history = TheServiceParticipant->initial_HistoryQosPolicy();
00617           tempDrQos.resource_limits =
00618             TheServiceParticipant->initial_ResourceLimitsQosPolicy();
00619           tempDrQos.user_data = bit.user_data;
00620           tempDrQos.ownership = bit.ownership;
00621           tempDrQos.time_based_filter = bit.time_based_filter;
00622           tempDrQos.reader_data_lifecycle =
00623             TheServiceParticipant->initial_ReaderDataLifecycleQosPolicy();
00624           drQos = &tempDrQos;
00625           tempSubQos.presentation = bit.presentation;
00626           tempSubQos.partition = bit.partition;
00627           tempSubQos.group_data = bit.group_data;
00628           tempSubQos.entity_factory =
00629             TheServiceParticipant->initial_EntityFactoryQosPolicy();
00630           subQos = &tempSubQos;
00631           cfProp = &dsi->second.reader_data_.contentFilterProperty;
00632         } else {
00633           return; // Possible and ok, since lock is released
00634         }
00635 
00636         // This is really part of step 1, but we're doing it here just in case we
00637         // are in the discovered/discovered match and we don't need the QoS data.
00638         if (!writer_local) {
00639           const DDS::PublicationBuiltinTopicData& bit =
00640             dpi->second.writer_data_.ddsPublicationData;
00641           tempDwQos.durability = bit.durability;
00642           tempDwQos.durability_service = bit.durability_service;
00643           tempDwQos.deadline = bit.deadline;
00644           tempDwQos.latency_budget = bit.latency_budget;
00645           tempDwQos.liveliness = bit.liveliness;
00646           tempDwQos.reliability = bit.reliability;
00647           tempDwQos.destination_order = bit.destination_order;
00648           tempDwQos.history = TheServiceParticipant->initial_HistoryQosPolicy();
00649           tempDwQos.resource_limits =
00650             TheServiceParticipant->initial_ResourceLimitsQosPolicy();
00651           tempDwQos.transport_priority =
00652             TheServiceParticipant->initial_TransportPriorityQosPolicy();
00653           tempDwQos.lifespan = bit.lifespan;
00654           tempDwQos.user_data = bit.user_data;
00655           tempDwQos.ownership = bit.ownership;
00656           tempDwQos.ownership_strength = bit.ownership_strength;
00657           tempDwQos.writer_data_lifecycle =
00658             TheServiceParticipant->initial_WriterDataLifecycleQosPolicy();
00659           dwQos = &tempDwQos;
00660           tempPubQos.presentation = bit.presentation;
00661           tempPubQos.partition = bit.partition;
00662           tempPubQos.group_data = bit.group_data;
00663           tempPubQos.entity_factory =
00664             TheServiceParticipant->initial_EntityFactoryQosPolicy();
00665           pubQos = &tempPubQos;
00666 
00667           populate_transport_locator_sequence(wTls, dpi, writer);
00668         }
00669 
00670         // Need to release lock, below, for callbacks into DCPS which could
00671         // call into Spdp/Sedp.  Note that this doesn't unlock, it just constructs
00672         // an ACE object which will be used below for unlocking.
00673         ACE_Reverse_Lock<ACE_Thread_Mutex> rev_lock(lock_);
00674 
00675         // 3. check transport and QoS compatibility
00676 
00677         // Copy entries from local publication and local subscription maps
00678         // prior to releasing lock
00679         DCPS::DataWriterCallbacks* dwr = 0;
00680         DCPS::DataReaderCallbacks* drr = 0;
00681         if (writer_local) {
00682           dwr = lpi->second.publication_;
00683         }
00684         if (reader_local) {
00685           drr = lsi->second.subscription_;
00686         }
00687 
00688         DCPS::IncompatibleQosStatus writerStatus = {0, 0, 0, DDS::QosPolicyCountSeq()};
00689         DCPS::IncompatibleQosStatus readerStatus = {0, 0, 0, DDS::QosPolicyCountSeq()};
00690 
00691         if (DCPS::compatibleQOS(&writerStatus, &readerStatus, *wTls, *rTls,
00692                                 dwQos, drQos, pubQos, subQos)) {
00693           if (!writer_local) {
00694             RepoId writer_participant = writer;
00695             writer_participant.entityId = ENTITYID_PARTICIPANT;
00696             if (defer_writer(writer, writer_participant)) {
00697               return;
00698             }
00699           }
00700           if (!reader_local) {
00701             RepoId reader_participant = reader;
00702             reader_participant.entityId = ENTITYID_PARTICIPANT;
00703             if (defer_reader(reader, reader_participant)) {
00704               return;
00705             }
00706           }
00707 
00708           bool call_writer = false, call_reader = false;
00709           if (writer_local) {
00710             call_writer = lpi->second.matched_endpoints_.insert(reader).second;
00711           }
00712           if (reader_local) {
00713             call_reader = lsi->second.matched_endpoints_.insert(writer).second;
00714           }
00715           if (!call_writer && !call_reader) {
00716             return; // nothing more to do
00717           }
00718           // Copy reader and writer association data prior to releasing lock
00719 #ifdef __SUNPRO_CC
00720           DCPS::ReaderAssociation ra;
00721           ra.readerTransInfo = *rTls;
00722           ra.readerId = reader;
00723           ra.subQos = *subQos;
00724           ra.readerQos = *drQos;
00725           ra.filterClassName = cfProp->filterClassName;
00726           ra.filterExpression = cfProp->filterExpression;
00727           ra.exprParams = cfProp->expressionParameters;
00728           DCPS::WriterAssociation wa;
00729           wa.writerTransInfo = *wTls;
00730           wa.writerId = writer;
00731           wa.pubQos = *pubQos;
00732           wa.writerQos = *dwQos;
00733 #else
00734           const DCPS::ReaderAssociation ra =
00735             {*rTls, reader, *subQos, *drQos,
00736 #ifndef OPENDDS_NO_CONTENT_FILTERED_TOPIC
00737              cfProp->filterClassName, cfProp->filterExpression,
00738 #else
00739              "", "",
00740 #endif
00741              cfProp->expressionParameters};
00742 
00743           const DCPS::WriterAssociation wa = {*wTls, writer, *pubQos, *dwQos};
00744 #endif
00745 
00746           ACE_GUARD(ACE_Reverse_Lock<ACE_Thread_Mutex>, rg, rev_lock);
00747           static const bool writer_active = true;
00748 
00749           if (call_writer) {
00750             if (DCPS::DCPS_debug_level > 3) {
00751               ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) EndpointManager::match - ")
00752                          ACE_TEXT("adding writer association\n")));
00753             }
00754             DcpsUpcalls thr(drr, reader, wa, !writer_active, dwr);
00755             if (call_reader) {
00756               thr.activate();
00757             }
00758             dwr->add_association(writer, ra, writer_active);
00759             if (call_reader) {
00760               thr.writer_done();
00761             }
00762 
00763           } else if (call_reader) {
00764             if (DCPS::DCPS_debug_level > 3) {
00765               ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) EndpointManager::match - ")
00766                          ACE_TEXT("adding reader association\n")));
00767             }
00768             drr->add_association(reader, wa, !writer_active);
00769           }
00770 
00771           // change this if 'writer_active' (above) changes
00772           if (call_writer && !call_reader && !is_opendds(reader)) {
00773             if (DCPS::DCPS_debug_level > 3) {
00774               ACE_DEBUG((LM_DEBUG,
00775                          ACE_TEXT("(%P|%t) EndpointManager::match - ")
00776                          ACE_TEXT("calling writer association_complete\n")));
00777             }
00778             dwr->association_complete(reader);
00779           }
00780 
00781         } else if (already_matched) { // break an existing associtaion
00782           if (writer_local) {
00783             lpi->second.matched_endpoints_.erase(reader);
00784             lpi->second.remote_opendds_associations_.erase(reader);
00785           }
00786           if (reader_local) {
00787             lsi->second.matched_endpoints_.erase(writer);
00788             lsi->second.remote_opendds_associations_.erase(writer);
00789           }
00790           ACE_GUARD(ACE_Reverse_Lock<ACE_Thread_Mutex>, rg, rev_lock);
00791           if (writer_local) {
00792             DCPS::ReaderIdSeq reader_seq(1);
00793             reader_seq.length(1);
00794             reader_seq[0] = reader;
00795             dwr->remove_associations(reader_seq, false /*notify_lost*/);
00796           }
00797           if (reader_local) {
00798             DCPS::WriterIdSeq writer_seq(1);
00799             writer_seq.length(1);
00800             writer_seq[0] = writer;
00801             drr->remove_associations(writer_seq, false /*notify_lost*/);
00802           }
00803 
00804         } else { // something was incompatible
00805           ACE_GUARD(ACE_Reverse_Lock< ACE_Thread_Mutex>, rg, rev_lock);
00806           if (writer_local && writerStatus.count_since_last_send) {
00807             if (DCPS::DCPS_debug_level > 3) {
00808               ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) EndpointManager::match - ")
00809                          ACE_TEXT("writer incompatible\n")));
00810             }
00811             dwr->update_incompatible_qos(writerStatus);
00812           }
00813           if (reader_local && readerStatus.count_since_last_send) {
00814             if (DCPS::DCPS_debug_level > 3) {
00815               ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) EndpointManager::match - ")
00816                          ACE_TEXT("reader incompatible\n")));
00817             }
00818             drr->update_incompatible_qos(readerStatus);
00819           }
00820         }
00821       }

template<typename DiscoveredParticipantData_>
void OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::match_endpoints ( DCPS::RepoId  repoId,
const TopicDetails &  td,
bool  remove = false 
) [inline, protected]

Definition at line 489 of file DiscoveryBase.h.

Referenced by OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::add_publication(), OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::add_subscription(), OpenDDS::RTPS::Sedp::data_received(), OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::ignore(), OpenDDS::RTPS::Sedp::remove_entities_belonging_to(), OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::remove_publication(), OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::remove_subscription(), and OpenDDS::RTPS::Sedp::Task::svc_i().

00491       {
00492         const bool reader = repoId.entityId.entityKind & 4;
00493         // Copy the endpoint set - lock can be released in match()
00494         RepoIdSet endpoints_copy = td.endpoints_;
00495 
00496         for (RepoIdSet::const_iterator iter = endpoints_copy.begin();
00497              iter != endpoints_copy.end(); ++iter) {
00498           // check to make sure it's a Reader/Writer or Writer/Reader match
00499           if (bool(iter->entityId.entityKind & 4) != reader) {
00500             if (remove) {
00501               remove_assoc(*iter, repoId);
00502             } else {
00503               match(reader ? *iter : repoId, reader ? repoId : *iter);
00504             }
00505           }
00506         }
00507       }

template<typename DiscoveredParticipantData_>
OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::OPENDDS_MAP ( OPENDDS_STRING  ,
TopicDetails   
) [protected]

Referenced by OpenDDS::DCPS::PeerDiscovery< OpenDDS::DCPS::StaticParticipant >::assert_topic(), OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::assert_topic(), OpenDDS::RTPS::Sedp::data_received(), OpenDDS::DCPS::PeerDiscovery< OpenDDS::DCPS::StaticParticipant >::find_topic(), OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::has_dcps_key(), OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::ignore(), OpenDDS::RTPS::Sedp::remove_entities_belonging_to(), OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::remove_publication(), OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::remove_subscription(), OpenDDS::DCPS::PeerDiscovery< OpenDDS::DCPS::StaticParticipant >::remove_topic(), OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::remove_topic(), and OpenDDS::RTPS::Sedp::Task::svc_i().

template<typename DiscoveredParticipantData_>
typedef OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::OPENDDS_MAP_CMP ( DCPS::RepoId  ,
OPENDDS_STRING  ,
DCPS::GUID_tKeyLessThan   
) [protected]

template<typename DiscoveredParticipantData_>
typedef OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::OPENDDS_MAP_CMP ( DCPS::RepoId  ,
LocalSubscription  ,
DCPS::GUID_tKeyLessThan   
) [protected]

template<typename DiscoveredParticipantData_>
typedef OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::OPENDDS_MAP_CMP ( DCPS::RepoId  ,
LocalPublication  ,
DCPS::GUID_tKeyLessThan   
) [protected]

template<typename DiscoveredParticipantData_>
typedef OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::OPENDDS_MAP_CMP ( DDS::BuiltinTopicKey_t  ,
DCPS::RepoId  ,
DCPS::BuiltinTopicKeyLess   
) [protected]

template<typename DiscoveredParticipantData_>
typedef OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::OPENDDS_MAP_CMP ( DCPS::RepoId  ,
DiscoveredPublication  ,
DCPS::GUID_tKeyLessThan   
) [protected]

template<typename DiscoveredParticipantData_>
typedef OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::OPENDDS_MAP_CMP ( DCPS::RepoId  ,
DiscoveredSubscription  ,
DCPS::GUID_tKeyLessThan   
) [protected]

Referenced by OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::has_dcps_key(), and OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::ignore().

template<typename DiscoveredParticipantData_>
OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::OPENDDS_SET ( OPENDDS_STRING   )  [protected]

template<typename DiscoveredParticipantData_>
virtual void OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::populate_transport_locator_sequence ( DCPS::TransportLocatorSeq *&  tls,
DiscoveredPublicationIter &  iter,
const RepoId &  reader 
) [protected, pure virtual]

template<typename DiscoveredParticipantData_>
virtual void OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::populate_transport_locator_sequence ( DCPS::TransportLocatorSeq *&  tls,
DiscoveredSubscriptionIter &  iter,
const RepoId &  reader 
) [protected, pure virtual]

Referenced by OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::match().

template<typename DiscoveredParticipantData_>
void OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::remove_assoc ( const RepoId &  remove_from,
const RepoId &  removing 
) [inline, protected]

Definition at line 510 of file DiscoveryBase.h.

Referenced by OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::match_endpoints().

00512       {
00513         const bool reader = remove_from.entityId.entityKind & 4;
00514         if (reader) {
00515           const LocalSubscriptionIter lsi = local_subscriptions_.find(remove_from);
00516           if (lsi != local_subscriptions_.end()) {
00517             lsi->second.matched_endpoints_.erase(removing);
00518             DCPS::WriterIdSeq writer_seq(1);
00519             writer_seq.length(1);
00520             writer_seq[0] = removing;
00521             lsi->second.remote_opendds_associations_.erase(removing);
00522             lsi->second.subscription_->remove_associations(writer_seq,
00523                                                            false /*notify_lost*/);
00524             // Update writer
00525             write_subscription_data(remove_from, lsi->second);
00526           }
00527 
00528         } else {
00529           const LocalPublicationIter lpi = local_publications_.find(remove_from);
00530           if (lpi != local_publications_.end()) {
00531             lpi->second.matched_endpoints_.erase(removing);
00532             DCPS::ReaderIdSeq reader_seq(1);
00533             reader_seq.length(1);
00534             reader_seq[0] = removing;
00535             lpi->second.remote_opendds_associations_.erase(removing);
00536             lpi->second.publication_->remove_associations(reader_seq,
00537                                                           false /*notify_lost*/);
00538           }
00539         }
00540       }

template<typename DiscoveredParticipantData_>
void OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::remove_from_bit ( const DiscoveredSubscription &  sub  )  [inline, protected]

Definition at line 851 of file DiscoveryBase.h.

00852       {
00853         sub_key_to_id_.erase(get_key(sub));
00854         remove_from_bit_i(sub);
00855       }

template<typename DiscoveredParticipantData_>
void OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::remove_from_bit ( const DiscoveredPublication &  pub  )  [inline, protected]

Definition at line 845 of file DiscoveryBase.h.

Referenced by OpenDDS::RTPS::Sedp::data_received(), OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::ignore(), and OpenDDS::RTPS::Sedp::remove_entities_belonging_to().

00846       {
00847         pub_key_to_id_.erase(get_key(pub));
00848         remove_from_bit_i(pub);
00849       }

template<typename DiscoveredParticipantData_>
virtual void OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::remove_from_bit_i ( const DiscoveredSubscription &   )  [inline, protected, virtual]

Definition at line 443 of file DiscoveryBase.h.

00443 { }

template<typename DiscoveredParticipantData_>
virtual void OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::remove_from_bit_i ( const DiscoveredPublication &   )  [inline, protected, virtual]

Definition at line 442 of file DiscoveryBase.h.

Referenced by OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::remove_from_bit().

00442 { }

template<typename DiscoveredParticipantData_>
void OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::remove_publication ( const DCPS::RepoId &  publicationId  )  [inline]

Definition at line 287 of file DiscoveryBase.h.

00288       {
00289         ACE_GUARD(ACE_Thread_Mutex, g, lock_);
00290         LocalPublicationIter iter = local_publications_.find(publicationId);
00291         if (iter != local_publications_.end()) {
00292           if (DDS::RETCODE_OK == remove_publication_i(publicationId))
00293             {
00294               OPENDDS_STRING topic_name = topic_names_[iter->second.topic_id_];
00295               local_publications_.erase(publicationId);
00296               typename OPENDDS_MAP(OPENDDS_STRING, TopicDetails)::iterator top_it =
00297                 topics_.find(topic_name);
00298               if (top_it != topics_.end()) {
00299                 match_endpoints(publicationId, top_it->second, true /*remove*/);
00300                 top_it->second.endpoints_.erase(publicationId);
00301               }
00302             } else {
00303             ACE_DEBUG((LM_ERROR,
00304                        ACE_TEXT("(%P|%t) ERROR: EndpointManager::remove_publication - ")
00305                        ACE_TEXT("Failed to publish dispose msg\n")));
00306           }
00307         }
00308       }

template<typename DiscoveredParticipantData_>
virtual DDS::ReturnCode_t OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::remove_publication_i ( const RepoId &  publicationId  )  [protected, pure virtual]

Implemented in OpenDDS::RTPS::Sedp, and OpenDDS::DCPS::StaticEndpointManager.

Referenced by OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::remove_publication().

template<typename DiscoveredParticipantData_>
void OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::remove_subscription ( const DCPS::RepoId &  subscriptionId  )  [inline]

Definition at line 356 of file DiscoveryBase.h.

00357       {
00358         ACE_GUARD(ACE_Thread_Mutex, g, lock_);
00359         LocalSubscriptionIter iter = local_subscriptions_.find(subscriptionId);
00360         if (iter != local_subscriptions_.end()) {
00361           if (DDS::RETCODE_OK == remove_subscription_i(subscriptionId)
00362               /*subscriptions_writer_.write_unregister_dispose(subscriptionId)*/) {
00363             OPENDDS_STRING topic_name = topic_names_[iter->second.topic_id_];
00364             local_subscriptions_.erase(subscriptionId);
00365             typename OPENDDS_MAP(OPENDDS_STRING, TopicDetails)::iterator top_it =
00366               topics_.find(topic_name);
00367             if (top_it != topics_.end()) {
00368               match_endpoints(subscriptionId, top_it->second, true /*remove*/);
00369               top_it->second.endpoints_.erase(subscriptionId);
00370             }
00371           } else {
00372             ACE_DEBUG((LM_ERROR,
00373                        ACE_TEXT("(%P|%t) ERROR: EndpointManager::remove_subscription - ")
00374                        ACE_TEXT("Failed to publish dispose msg\n")));
00375           }
00376         }
00377       }

template<typename DiscoveredParticipantData_>
virtual DDS::ReturnCode_t OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::remove_subscription_i ( const RepoId &  subscriptionId  )  [protected, pure virtual]

Implemented in OpenDDS::RTPS::Sedp, and OpenDDS::DCPS::StaticEndpointManager.

Referenced by OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::remove_subscription().

template<typename DiscoveredParticipantData_>
DCPS::TopicStatus OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::remove_topic ( const RepoId &  topicId,
OPENDDS_STRING &  name 
) [inline]

Definition at line 232 of file DiscoveryBase.h.

00233       {
00234         ACE_GUARD_RETURN(ACE_Thread_Mutex, g, lock_, DCPS::INTERNAL_ERROR);
00235         name = topic_names_[topicId];
00236         typename OPENDDS_MAP(OPENDDS_STRING, TopicDetails)::iterator top_it =
00237           topics_.find(name);
00238         if (top_it != topics_.end()) {
00239           TopicDetails& td = top_it->second;
00240           if (td.endpoints_.empty()) {
00241             topics_.erase(name);
00242           }
00243         }
00244 
00245         topic_names_.erase(topicId);
00246         return DCPS::REMOVED;
00247       }

template<typename DiscoveredParticipantData_>
virtual bool OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::shutting_down (  )  const [protected, pure virtual]

Implemented in OpenDDS::RTPS::Sedp, and OpenDDS::DCPS::StaticEndpointManager.

Referenced by OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::ignore().

template<typename DiscoveredParticipantData_>
virtual bool OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::update_publication_qos ( const DCPS::RepoId &  publicationId,
const DDS::DataWriterQos &  qos,
const DDS::PublisherQos &  publisherQos 
) [pure virtual]

Implemented in OpenDDS::RTPS::Sedp, and OpenDDS::DCPS::StaticEndpointManager.

template<typename DiscoveredParticipantData_>
virtual bool OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::update_subscription_params ( const DCPS::RepoId &  subId,
const DDS::StringSeq &  params 
) [pure virtual]

Implemented in OpenDDS::RTPS::Sedp, and OpenDDS::DCPS::StaticEndpointManager.

template<typename DiscoveredParticipantData_>
virtual bool OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::update_subscription_qos ( const DCPS::RepoId &  subscriptionId,
const DDS::DataReaderQos &  qos,
const DDS::SubscriberQos &  subscriberQos 
) [pure virtual]

Implemented in OpenDDS::RTPS::Sedp, and OpenDDS::DCPS::StaticEndpointManager.

template<typename DiscoveredParticipantData_>
virtual bool OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::update_topic_qos ( const DCPS::RepoId &  topicId,
const DDS::TopicQos &  qos,
OPENDDS_STRING &  name 
) [pure virtual]

Implemented in OpenDDS::RTPS::Sedp, and OpenDDS::DCPS::StaticEndpointManager.

Referenced by OpenDDS::DCPS::PeerDiscovery< OpenDDS::DCPS::StaticParticipant >::update_topic_qos().

template<typename DiscoveredParticipantData_>
virtual DDS::ReturnCode_t OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::write_publication_data ( const DCPS::RepoId &  ,
LocalPublication &  ,
const DCPS::RepoId &  reader = DCPS::GUID_UNKNOWN 
) [inline, protected, virtual]

Definition at line 477 of file DiscoveryBase.h.

Referenced by OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::add_publication().

00479                                                                                                     { ACE_UNUSED_ARG(reader); return DDS::RETCODE_OK; }

template<typename DiscoveredParticipantData_>
virtual DDS::ReturnCode_t OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::write_subscription_data ( const DCPS::RepoId &  ,
LocalSubscription &  ,
const DCPS::RepoId &  reader = DCPS::GUID_UNKNOWN 
) [inline, protected, virtual]

Definition at line 484 of file DiscoveryBase.h.

Referenced by OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::add_subscription(), and OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::remove_assoc().

00486                                                                                                      { ACE_UNUSED_ARG(reader); return DDS::RETCODE_OK; }

Member Data Documentation

template<typename DiscoveredParticipantData_>
DiscoveredPublicationMap OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::discovered_publications_ [protected]

Definition at line 903 of file DiscoveryBase.h.

Referenced by OpenDDS::RTPS::Sedp::data_received(), OpenDDS::RTPS::Sedp::disassociate(), OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::ignore(), OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::match(), and OpenDDS::RTPS::Sedp::Task::svc_i().

template<typename DiscoveredParticipantData_>
DiscoveredSubscriptionMap OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::discovered_subscriptions_ [protected]

Definition at line 904 of file DiscoveryBase.h.

Referenced by OpenDDS::RTPS::Sedp::data_received(), OpenDDS::RTPS::Sedp::disassociate(), OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::ignore(), OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::match(), and OpenDDS::RTPS::Sedp::Task::svc_i().

template<typename DiscoveredParticipantData_>
RepoIdSet OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::ignored_guids_ [protected]

Definition at line 899 of file DiscoveryBase.h.

Referenced by OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::ignore(), and OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::ignoring().

template<typename DiscoveredParticipantData_>
LocalPublicationMap OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::local_publications_ [protected]

Definition at line 901 of file DiscoveryBase.h.

Referenced by OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::add_publication(), OpenDDS::RTPS::Sedp::data_received(), OpenDDS::RTPS::Sedp::inconsistent_topic(), OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::match(), OpenDDS::DCPS::StaticEndpointManager::reader_does_not_exist(), OpenDDS::DCPS::StaticEndpointManager::reader_exists(), OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::remove_assoc(), OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::remove_publication(), OpenDDS::DCPS::StaticEndpointManager::remove_publication_i(), and OpenDDS::RTPS::Sedp::write_durable_publication_data().

template<typename DiscoveredParticipantData_>
LocalSubscriptionMap OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::local_subscriptions_ [protected]

Definition at line 902 of file DiscoveryBase.h.

Referenced by OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::add_subscription(), OpenDDS::RTPS::Sedp::data_received(), OpenDDS::RTPS::Sedp::inconsistent_topic(), OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::match(), OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::remove_assoc(), OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::remove_subscription(), OpenDDS::DCPS::StaticEndpointManager::remove_subscription_i(), OpenDDS::RTPS::Sedp::write_durable_subscription_data(), OpenDDS::DCPS::StaticEndpointManager::writer_does_not_exist(), and OpenDDS::DCPS::StaticEndpointManager::writer_exists().

template<typename DiscoveredParticipantData_>
ACE_Thread_Mutex& OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::lock_ [protected]

Definition at line 896 of file DiscoveryBase.h.

Referenced by OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::add_publication(), OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::add_subscription(), OpenDDS::DCPS::PeerDiscovery< OpenDDS::DCPS::StaticParticipant >::assert_topic(), OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::assert_topic(), OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::bit_key_to_repo_id(), OpenDDS::RTPS::Sedp::data_received(), OpenDDS::RTPS::Sedp::disassociate(), OpenDDS::DCPS::PeerDiscovery< OpenDDS::DCPS::StaticParticipant >::find_topic(), OpenDDS::DCPS::PeerDiscovery< OpenDDS::DCPS::StaticParticipant >::get_part(), OpenDDS::DCPS::LocalParticipant< OpenDDS::DCPS::StaticEndpointManager >::ignore_domain_participant(), OpenDDS::DCPS::LocalParticipant< OpenDDS::DCPS::StaticEndpointManager >::ignore_publication(), OpenDDS::DCPS::LocalParticipant< OpenDDS::DCPS::StaticEndpointManager >::ignore_subscription(), OpenDDS::DCPS::LocalParticipant< OpenDDS::DCPS::StaticEndpointManager >::ignore_topic(), OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::match(), OpenDDS::DCPS::StaticEndpointManager::reader_does_not_exist(), OpenDDS::DCPS::StaticEndpointManager::reader_exists(), OpenDDS::DCPS::PeerDiscovery< OpenDDS::DCPS::StaticParticipant >::remove_domain_participant(), OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::remove_publication(), OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::remove_subscription(), OpenDDS::DCPS::PeerDiscovery< OpenDDS::DCPS::StaticParticipant >::remove_topic(), OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::remove_topic(), OpenDDS::RTPS::Sedp::Task::svc_i(), OpenDDS::DCPS::LocalParticipant< OpenDDS::DCPS::StaticEndpointManager >::update_domain_participant_qos(), OpenDDS::DCPS::PeerDiscovery< OpenDDS::DCPS::StaticParticipant >::update_topic_qos(), OpenDDS::DCPS::StaticEndpointManager::writer_does_not_exist(), and OpenDDS::DCPS::StaticEndpointManager::writer_exists().

template<typename DiscoveredParticipantData_>
DCPS::RepoId OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::participant_id_ [protected]

Definition at line 897 of file DiscoveryBase.h.

Referenced by OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::add_publication(), OpenDDS::DCPS::StaticEndpointManager::add_publication_i(), OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::add_subscription(), OpenDDS::DCPS::StaticEndpointManager::add_subscription_i(), OpenDDS::RTPS::Sedp::inconsistent_topic(), OpenDDS::DCPS::StaticEndpointManager::init_bit(), OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::make_topic_guid(), OpenDDS::DCPS::StaticEndpointManager::remove_publication_i(), OpenDDS::DCPS::StaticEndpointManager::remove_subscription_i(), and OpenDDS::RTPS::Sedp::signal_liveliness().

template<typename DiscoveredParticipantData_>
DDS::BuiltinTopicKey_t OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::pub_bit_key_ [protected]

Definition at line 908 of file DiscoveryBase.h.

Referenced by OpenDDS::RTPS::Sedp::assign_bit_key(), OpenDDS::DCPS::StaticEndpointManager::init_bit(), and OpenDDS::DCPS::StaticEndpointManager::StaticEndpointManager().

template<typename DiscoveredParticipantData_>
BitKeyMap OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::pub_key_to_id_ [protected]

Definition at line 898 of file DiscoveryBase.h.

Referenced by OpenDDS::RTPS::Sedp::assign_bit_key(), OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::bit_key_to_repo_id(), OpenDDS::DCPS::StaticEndpointManager::init_bit(), and OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::remove_from_bit().

template<typename DiscoveredParticipantData_>
unsigned int OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::publication_counter_ [protected]

Definition at line 900 of file DiscoveryBase.h.

Referenced by OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::assign_publication_key().

template<typename DiscoveredParticipantData_>
DDS::BuiltinTopicKey_t OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::sub_bit_key_ [protected]

Definition at line 908 of file DiscoveryBase.h.

Referenced by OpenDDS::RTPS::Sedp::assign_bit_key(), OpenDDS::DCPS::StaticEndpointManager::init_bit(), and OpenDDS::DCPS::StaticEndpointManager::StaticEndpointManager().

template<typename DiscoveredParticipantData_>
BitKeyMap OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::sub_key_to_id_ [protected]

Definition at line 898 of file DiscoveryBase.h.

Referenced by OpenDDS::RTPS::Sedp::assign_bit_key(), OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::bit_key_to_repo_id(), OpenDDS::DCPS::StaticEndpointManager::init_bit(), and OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::remove_from_bit().

template<typename DiscoveredParticipantData_>
unsigned int OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::subscription_counter_ [protected]

Definition at line 900 of file DiscoveryBase.h.

Referenced by OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::assign_subscription_key().

template<typename DiscoveredParticipantData_>
unsigned int OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::topic_counter_ [protected]

Definition at line 900 of file DiscoveryBase.h.

Referenced by OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::assign_topic_key().

template<typename DiscoveredParticipantData_>
TopicNameMap OpenDDS::DCPS::EndpointManager< DiscoveredParticipantData_ >::topic_names_ [protected]

Definition at line 906 of file DiscoveryBase.h.

Referenced by OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::add_publication(), OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::add_subscription(), OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::assert_topic(), OpenDDS::RTPS::Sedp::data_received(), OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::has_dcps_key(), OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::ignore(), OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::remove_publication(), OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::remove_subscription(), and OpenDDS::DCPS::EndpointManager< OpenDDS::DCPS::StaticDiscoveredParticipantData >::remove_topic().

The documentation for this class was generated from the following file:
Generated on Fri Feb 12 20:06:15 2016 for OpenDDS by  doxygen 1.4.7