Mix-in class for DDS entities which directly use the transport layer. More...

#include <TransportClient.h>

Inheritance diagram for OpenDDS::DCPS::TransportClient:

[legend]

Collaboration diagram for OpenDDS::DCPS::TransportClient:

[legend]

Classes
struct	PendingAssoc

class	PendingAssocTimer

Public Types
enum	{ ASSOC_OK = 1, ASSOC_ACTIVE = 2 }

Public Member Functions
void	use_datalink (const GUID_t &remote_id, const DataLink_rch &link)

	TransportClient ()

virtual	~TransportClient ()

void	enable_transport (bool reliable, bool durable)

void	enable_transport_using_config (bool reliable, bool durable, const TransportConfig_rch &tc)

bool	swap_bytes () const

bool	cdr_encapsulation () const

const TransportLocatorSeq &	connection_info () const

void	populate_connection_info ()

bool	is_reliable () const

bool	associate (const AssociationData &peer, bool active)

void	disassociate (const GUID_t &peerId)

void	stop_associating ()

void	stop_associating (const GUID_t *repos, CORBA::ULong length)

void	send_final_acks ()

void	transport_stop ()

void	register_for_reader (const GUID_t &participant, const GUID_t &writerid, const GUID_t &readerid, const TransportLocatorSeq &locators, OpenDDS::DCPS::DiscoveryListener *listener)

void	unregister_for_reader (const GUID_t &participant, const GUID_t &writerid, const GUID_t &readerid)

void	register_for_writer (const GUID_t &participant, const GUID_t &readerid, const GUID_t &writerid, const TransportLocatorSeq &locators, DiscoveryListener *listener)

void	unregister_for_writer (const GUID_t &participant, const GUID_t &readerid, const GUID_t &writerid)

void	update_locators (const GUID_t &remote, const TransportLocatorSeq &locators)

WeakRcHandle< ICE::Endpoint >	get_ice_endpoint ()

bool	send_response (const GUID_t &peer, const DataSampleHeader &header, Message_Block_Ptr payload)

void	send (SendStateDataSampleList send_list, ACE_UINT64 transaction_id=0)

SendControlStatus	send_w_control (SendStateDataSampleList send_list, const DataSampleHeader &header, Message_Block_Ptr msg, const GUID_t &destination)

SendControlStatus	send_control (const DataSampleHeader &header, Message_Block_Ptr msg)

SendControlStatus	send_control_to (const DataSampleHeader &header, Message_Block_Ptr msg, const GUID_t &destination)

bool	remove_sample (const DataSampleElement *sample)

bool	remove_all_msgs ()

virtual void	add_link (const DataLink_rch &link, const GUID_t &peer)

virtual GUID_t	get_guid () const =0

virtual RcHandle< BitSubscriber >	get_builtin_subscriber_proxy () const

void	terminate_send_if_suspended ()

bool	associated_with (const GUID_t &remote) const

bool	pending_association_with (const GUID_t &remote) const

GUID_t	repo_id () const

void	data_acked (const GUID_t &remote)

bool	is_leading (const GUID_t &reader_id) const

Public Member Functions inherited from OpenDDS::DCPS::RcObject
virtual	~RcObject ()

virtual void	_add_ref ()

virtual void	_remove_ref ()

long	ref_count () const

WeakObject *	_get_weak_object () const

Protected Member Functions
void	cdr_encapsulation (bool encap)

Protected Member Functions inherited from OpenDDS::DCPS::RcObject
	RcObject ()

Private Types
typedef ACE_Guard< ACE_Thread_Mutex >	Guard

typedef ACE_Reverse_Lock< ACE_Thread_Mutex >	Reverse_Lock_t

typedef RcHandle< PendingAssoc >	PendingAssoc_rch

Private Member Functions
virtual bool	check_transport_qos (const TransportInst &inst)=0

virtual DDS::DomainId_t	domain_id () const =0

virtual Priority	get_priority_value (const AssociationData &data) const =0

virtual void	transport_assoc_done (int, const GUID_t &)

virtual SequenceNumber	get_max_sn () const

virtual DDS::Security::ParticipantCryptoHandle	get_crypto_handle () const

void	use_datalink_i (const GUID_t &remote_id, const DataLink_rch &link, Guard &guard)

TransportSendListener_rch	get_send_listener ()

TransportReceiveListener_rch	get_receive_listener ()

bool	initiate_connect_i (TransportImpl::AcceptConnectResult &result, TransportImpl_rch impl, const TransportImpl::RemoteTransport &remote, const TransportImpl::ConnectionAttribs &attribs_, Guard &guard)

void	send_i (SendStateDataSampleList send_list, ACE_UINT64 transaction_id)

typedef	OPENDDS_MAP_CMP (GUID_t, DataLink_rch, GUID_tKeyLessThan) DataLinkIndex

typedef	OPENDDS_VECTOR (WeakRcHandle< TransportImpl >) ImplsType

typedef	OPENDDS_MAP_CMP (GUID_t, PendingAssoc_rch, GUID_tKeyLessThan) PendingMap

typedef	OPENDDS_MULTIMAP_CMP (GUID_t, PendingAssoc_rch, GUID_tKeyLessThan) PrevPendingMap

void	clean_prev_pending ()

Private Attributes
RcHandle< PendingAssocTimer >	pending_assoc_timer_

TransportConfig_rch	config_

ImplsType	impls_

PendingMap	pending_

PrevPendingMap	prev_pending_

DataLinkSet	links_

DataLinkIndex	data_link_index_

ACE_Thread_Mutex	send_transaction_lock_

ACE_UINT64	expected_transaction_id_

ACE_UINT64	max_transaction_id_seen_

DataSampleElement *	max_transaction_tail_

bool	swap_bytes_

bool	cdr_encapsulation_

bool	reliable_

bool	durable_

TimeDuration	passive_connect_duration_

TransportLocatorSeq	conn_info_

ACE_Thread_Mutex	lock_
	Seems to protect accesses to impls_, pending_, links_, data_link_index_. More...

Reverse_Lock_t	reverse_lock_

GUID_t	repo_id_

Friends
class	::DDS_TEST

Detailed Description

Mix-in class for DDS entities which directly use the transport layer.

DataReaderImpl and DataWriterImpl are TransportClients. The TransportClient class manages the TransportImpl objects that represent the available communication mechanisms and the DataLink objects that represent the currently active communication channels to peers.

Definition at line 47 of file TransportClient.h.

Member Typedef Documentation

◆ Guard

typedef ACE_Guard<ACE_Thread_Mutex> OpenDDS::DCPS::TransportClient::Guard

private

Definition at line 174 of file TransportClient.h.

◆ PendingAssoc_rch

typedef RcHandle<PendingAssoc> OpenDDS::DCPS::TransportClient::PendingAssoc_rch

private

Definition at line 222 of file TransportClient.h.

◆ Reverse_Lock_t

typedef ACE_Reverse_Lock<ACE_Thread_Mutex> OpenDDS::DCPS::TransportClient::Reverse_Lock_t

private

Definition at line 199 of file TransportClient.h.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum

Enumerator
ASSOC_OK
ASSOC_ACTIVE

Definition at line 55 of file TransportClient.h.

55 { ASSOC_OK = 1, ASSOC_ACTIVE = 2 };

OpenDDS::DCPS::TransportClient::ASSOC_ACTIVE

Definition: TransportClient.h:55

OpenDDS::DCPS::TransportClient::ASSOC_OK

Definition: TransportClient.h:55

Constructor & Destructor Documentation

◆ TransportClient()

OpenDDS::DCPS::TransportClient::TransportClient ( )

Definition at line 34 of file TransportClient.cpp.

   : pending_assoc_timer_(make_rch<PendingAssocTimer> (TheServiceParticipant->reactor(), TheServiceParticipant->reactor_owner()))
   , expected_transaction_id_(1)
   , max_transaction_id_seen_(0)
   , max_transaction_tail_(0)
   , swap_bytes_(false)
   , cdr_encapsulation_(false)
   , reliable_(false)
   , durable_(false)
   , reverse_lock_(lock_)
   , repo_id_(GUID_UNKNOWN)
 {
 }

◆ ~TransportClient()

OpenDDS::DCPS::TransportClient::~TransportClient ( )

virtual

Definition at line 48 of file TransportClient.cpp.

References ACE_DEBUG, ACE_GUARD, ACE_TEXT(), OpenDDS::DCPS::LogGuid::c_str(), impls_, LM_DEBUG, lock_, prev_pending_, repo_id_, OpenDDS::DCPS::TransportImpl::stop_accepting_or_connecting(), stop_associating(), and OpenDDS::DCPS::Transport_debug_level.

 {
   if (Transport_debug_level > 5) {
     LogGuid logger(repo_id_);
     ACE_DEBUG((LM_DEBUG,
                ACE_TEXT("(%P|%t) TransportClient::~TransportClient: %C\n"),
                logger.c_str()));
   }
 
   stop_associating();
 
   ACE_GUARD(ACE_Thread_Mutex, guard, lock_);
 
   for (PrevPendingMap::iterator it = prev_pending_.begin(); it != prev_pending_.end(); ++it) {
     for (size_t i = 0; i < impls_.size(); ++i) {
       TransportImpl_rch impl = impls_[i].lock();
       if (impl) {
         impl->stop_accepting_or_connecting(it->second->client_, it->second->data_.remote_id_, false, false);
       }
     }
   }
 }

Member Function Documentation

◆ add_link()

void OpenDDS::DCPS::TransportClient::add_link	(	const DataLink_rch &	link,
		const GUID_t &	peer
	)

virtual

Reimplemented in OpenDDS::DCPS::DataReaderImpl.

Definition at line 617 of file TransportClient.cpp.

References data_link_index_, get_receive_listener(), get_send_listener(), OpenDDS::DCPS::DataLinkSet::insert_link(), links_, OpenDDS::DCPS::DataLink::make_reservation(), reliable_, and repo_id_.

Referenced by OpenDDS::DCPS::DataReaderImpl::add_link(), and use_datalink_i().

 {
   links_.insert_link(link);
   data_link_index_[peer] = link;
 
   TransportReceiveListener_rch trl = get_receive_listener();
 
   if (trl) {
     link->make_reservation(peer, repo_id_, trl, reliable_);
 
   } else {
     link->make_reservation(peer, repo_id_, get_send_listener(), reliable_);
   }
 }

◆ associate()

bool OpenDDS::DCPS::TransportClient::associate	(	const AssociationData &	peer,
		bool	active
	)

Definition at line 199 of file TransportClient.cpp.

Referenced by OpenDDS::DCPS::RecorderImpl::add_association(), OpenDDS::DCPS::ReplayerImpl::add_association(), OpenDDS::DCPS::DataWriterImpl::add_association(), OpenDDS::DCPS::DataReaderImpl::add_association(), OpenDDS::RTPS::Sedp::Writer::assoc(), and OpenDDS::RTPS::Sedp::Reader::assoc().

 {
   GUID_t repo_id = get_guid();
 
   ACE_GUARD_RETURN(ACE_Thread_Mutex, guard, lock_, false);
 
   repo_id_ = repo_id;
 
   if (impls_.empty()) {
     if (DCPS_debug_level) {
       LogGuid writer_log(repo_id_);
       LogGuid reader_log(data.remote_id_);
       ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) TransportClient::associate - ")
                  ACE_TEXT("local %C remote %C no available impls\n"),
                  writer_log.c_str(),
                  reader_log.c_str()));
     }
     return false;
   }
 
   bool all_impls_shut_down = true;
   for (size_t i = 0; i < impls_.size(); ++i) {
     TransportImpl_rch impl = impls_[i].lock();
     if (impl && !impl->is_shut_down()) {
       all_impls_shut_down = false;
       break;
     }
   }
 
   if (all_impls_shut_down) {
     if (DCPS_debug_level) {
       LogGuid writer_log(repo_id_);
       LogGuid reader_log(data.remote_id_);
       ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) TransportClient::associate - ")
                  ACE_TEXT("local %C remote %C all available impls previously shutdown\n"),
                  writer_log.c_str(),
                  reader_log.c_str()));
     }
     return false;
   }
 
   clean_prev_pending();
 
   PendingMap::iterator iter = pending_.find(data.remote_id_);
 
   if (iter == pending_.end()) {
     GUID_t remote_copy(data.remote_id_);
     PendingAssoc_rch pa = make_rch<PendingAssoc>(rchandle_from(this));
     pa->active_ = active;
     pa->impls_.clear();
     pa->blob_index_ = 0;
     pa->data_ = data;
     pa->attribs_.local_id_ = repo_id_;
     pa->attribs_.priority_ = get_priority_value(data);
     pa->attribs_.local_reliable_ = reliable_;
     pa->attribs_.local_durable_ = durable_;
     pa->attribs_.max_sn_ = get_max_sn();
     iter = pending_.insert(std::make_pair(remote_copy, pa)).first;
 
     LogGuid tc_assoc_log(repo_id_);
     LogGuid remote_log(data.remote_id_);
     VDBG_LVL((LM_DEBUG, "(%P|%t) TransportClient::associate added PendingAssoc "
               "between %C and remote %C\n",
               tc_assoc_log.c_str(),
               remote_log.c_str()), 0);
   } else {
 
     ACE_ERROR((LM_ERROR,
                ACE_TEXT("(%P|%t) ERROR: TransportClient::associate ")
                ACE_TEXT("already associating with remote.\n")));
 
     return false;
 
   }
 
   PendingAssoc_rch pend = iter->second;
 
   if (active) {
     ACE_GUARD_RETURN(ACE_Thread_Mutex, pend_guard, pend->mutex_, false);
     pend->impls_.reserve(impls_.size());
     std::reverse_copy(impls_.begin(), impls_.end(),
                       std::back_inserter(pend->impls_));
 
     return pend->initiate_connect(this, guard);
 
   } else { // passive
 
     // call accept_datalink for each impl / blob pair of the same type
     for (size_t i = 0; i < impls_.size(); ++i) {
       // Release the PendingAssoc object's mutex_ since the nested for-loop does not access
       // the PendingAssoc object directly and the functions called by the nested loop can
       // lead to a PendingAssoc object's mutex_ being acquired, which will cause deadlock if
       // it is not released here.
       TransportImpl::ConnectionAttribs attribs;
       TransportImpl_rch impl = impls_[i].lock();
       {
         ACE_GUARD_RETURN(ACE_Thread_Mutex, pend_guard, pend->mutex_, false);
         pend->impls_.push_back(impl);
         attribs = pend->attribs_;
       }
       const OPENDDS_STRING type = impl->transport_type();
 
       for (CORBA::ULong j = 0; j < data.remote_data_.length(); ++j) {
         if (data.remote_data_[j].transport_type.in() == type) {
           const TransportImpl::RemoteTransport remote = {
             data.remote_id_, data.remote_data_[j].data, data.discovery_locator_.data, data.participant_discovered_at_, data.remote_transport_context_,
             data.publication_transport_priority_,
             data.remote_reliable_, data.remote_durable_};
 
           TransportImpl::AcceptConnectResult res;
           {
             // This thread acquired lock_ at the beginning of this method.
             // Calling accept_datalink might require getting the lock for the transport's reactor.
             // If the current thread is not an event handler for the transport's reactor, e.g.,
             // the ORB's thread, then the order of acquired locks will be lock_ -> transport reactor lock.
             // Event handlers in the transport reactor may call passive_connection which calls use_datalink
             // which acquires lock_.  The locking order in this case is transport reactor lock -> lock_.
             // To avoid deadlock, we must reverse the lock.
             RcHandle<TransportClient> client = rchandle_from(this);
             ACE_GUARD_RETURN(Reverse_Lock_t, rev_tc_guard, reverse_lock_, false);
             res = impl->accept_datalink(remote, attribs, client);
           }
 
           //NEED to check that pend is still valid here after you re-acquire the lock_ after accepting the datalink
           iter = pending_.find(data.remote_id_);
 
           if (iter == pending_.end()) {
             //If Pending Assoc is no longer in pending_ then use_datalink_i has been called from an
             //active side connection and completed, thus pend was removed from pending_.  Can return true.
             return true;
           }
           pend = iter->second;
 
           if (res.success_) {
             if (res.link_.is_nil()) {
               // In this case, it may be waiting for the TCP connection to be
               // established.  Just wait without trying other transports.
               pending_assoc_timer_->schedule_timer(rchandle_from(this), iter->second);
             } else {
               use_datalink_i(data.remote_id_, res.link_, guard);
               return true;
             }
           }
         }
       }
     }
 
     pending_assoc_timer_->schedule_timer(rchandle_from(this), iter->second);
   }
 
   return true;
 }

◆ associated_with()

bool OpenDDS::DCPS::TransportClient::associated_with ( const GUID_t & remote ) const

Definition at line 1154 of file TransportClient.cpp.

References ACE_ERROR, data_link_index_, LM_ERROR, lock_, and ACE_Guard< ACE_LOCK >::locked().

 {
   ACE_Guard<ACE_Thread_Mutex> guard(lock_);
   if (!guard.locked()) {
     ACE_ERROR((LM_ERROR, "(%P|%t) ERROR: TransportClient::associated_with: "
       "lock failed\n"));
     return false;
   }
   return data_link_index_.count(remote);
 }

◆ cdr_encapsulation() [1/2]

bool OpenDDS::DCPS::TransportClient::cdr_encapsulation ( ) const

inline

Definition at line 67 of file TransportClient.h.

Referenced by OpenDDS::DCPS::ReplayerImpl::create_sample_data_message(), OpenDDS::DCPS::DataWriterImpl::create_sample_data_message(), OpenDDS::DCPS::ReplayerImpl::enable(), OpenDDS::DCPS::DataWriterImpl::enable(), OpenDDS::DCPS::DataWriterImpl::serialize_sample(), and OpenDDS::DCPS::DataWriterImpl::setup_serialization().

67 { return cdr_encapsulation_; }

OpenDDS::DCPS::TransportClient::cdr_encapsulation_

bool cdr_encapsulation_

Definition: TransportClient.h:340

◆ cdr_encapsulation() [2/2]

void OpenDDS::DCPS::TransportClient::cdr_encapsulation ( bool encap )

inlineprotected

Definition at line 150 of file TransportClient.h.

   {
     cdr_encapsulation_ = encap;
   }

◆ check_transport_qos()

virtual bool OpenDDS::DCPS::TransportClient::check_transport_qos ( const TransportInst & inst )

privatepure virtual

Implemented in OpenDDS::DCPS::DataReaderImpl, OpenDDS::RTPS::Sedp::Endpoint, OpenDDS::DCPS::DataWriterImpl, OpenDDS::DCPS::ReplayerImpl, and OpenDDS::DCPS::RecorderImpl.

Referenced by enable_transport_using_config(), and populate_connection_info().

◆ clean_prev_pending()

void OpenDDS::DCPS::TransportClient::clean_prev_pending ( )

private

Definition at line 72 of file TransportClient.cpp.

References prev_pending_.

Referenced by associate().

 {
   for (PrevPendingMap::iterator it = prev_pending_.begin(); it != prev_pending_.end();) {
     if (it->second->safe_to_remove()) {
       prev_pending_.erase(it++);
     } else {
       ++it;
     }
   }
 }

◆ connection_info()

const TransportLocatorSeq& OpenDDS::DCPS::TransportClient::connection_info ( ) const

inline

Definition at line 68 of file TransportClient.h.

Referenced by OpenDDS::DCPS::RecorderImpl::enable(), OpenDDS::DCPS::ReplayerImpl::enable(), OpenDDS::DCPS::DataWriterImpl::enable(), OpenDDS::DCPS::DataReaderImpl::enable(), and OpenDDS::DCPS::DataWriterImpl::transport_discovery_change().

68 { return conn_info_; }

OpenDDS::DCPS::TransportClient::conn_info_

TransportLocatorSeq conn_info_

Definition: TransportClient.h:344

◆ data_acked()

void OpenDDS::DCPS::TransportClient::data_acked ( const GUID_t & remote )

Definition at line 1176 of file TransportClient.cpp.

References ACE_ERROR, get_send_listener(), LM_ERROR, lock_, and ACE_Guard< ACE_LOCK >::locked().

 {
   TransportSendListener_rch send_listener;
   {
     ACE_Guard<ACE_Thread_Mutex> guard(lock_);
     if (!guard.locked()) {
       ACE_ERROR((LM_ERROR, "(%P|%t) ERROR: TransportClient::data_acked: "
         "lock failed\n"));
       return;
     }
     send_listener = get_send_listener();
   }
   send_listener->data_acked(remote);
 }

◆ disassociate()

void OpenDDS::DCPS::TransportClient::disassociate ( const GUID_t & peerId )

Definition at line 691 of file TransportClient.cpp.

References ACE_DEBUG, ACE_GUARD, ACE_TEXT(), OpenDDS::DCPS::LogGuid::c_str(), data_link_index_, OpenDDS::DCPS::DCPS_debug_level, OpenDDS::DCPS::RcHandle< T >::in(), links_, LM_DEBUG, lock_, pending_, pending_assoc_timer_, prev_pending_, OpenDDS::DCPS::DataLink::release_reservations(), OpenDDS::DCPS::DataLinkSet::remove_link(), OpenDDS::DCPS::DataLink::remove_listener(), repo_id_, OpenDDS::DCPS::TransportImpl::stop_accepting_or_connecting(), and VDBG_LVL.

Referenced by OpenDDS::RTPS::disassociate_helper_extended(), OpenDDS::RTPS::Sedp::Endpoint::get_priority_value(), OpenDDS::DCPS::ReplayerImpl::remove_associations(), OpenDDS::DCPS::DataWriterImpl::remove_associations(), OpenDDS::DCPS::RecorderImpl::remove_associations_i(), and OpenDDS::DCPS::DataReaderImpl::remove_associations_i().

 {
   LogGuid peerId_log(peerId);
   VDBG_LVL((LM_DEBUG, "(%P|%t) TransportClient::disassociate "
             "TransportClient(%@) disassociating from %C\n",
             this,
             peerId_log.c_str()), 5);
 
   ACE_GUARD(ACE_Thread_Mutex, guard, lock_);
 
   PendingMap::iterator iter = pending_.find(peerId);
   if (iter != pending_.end()) {
     {
       // The transport impl may have resource for a pending connection.
       ACE_Guard<ACE_Thread_Mutex> guard(iter->second->mutex_);
       for (size_t i = 0; i < iter->second->impls_.size(); ++i) {
         TransportImpl_rch impl = iter->second->impls_[i].lock();
         if (impl) {
           impl->stop_accepting_or_connecting(*this, iter->second->data_.remote_id_, true, true);
         }
       }
     }
     iter->second->reset_client();
     pending_assoc_timer_->cancel_timer(iter->second);
     prev_pending_.insert(std::make_pair(iter->first, iter->second));
     pending_.erase(iter);
     return;
   }
 
   const DataLinkIndex::iterator found = data_link_index_.find(peerId);
 
   if (found == data_link_index_.end()) {
     if (DCPS_debug_level > 4) {
       const LogGuid log(peerId);
       ACE_DEBUG((LM_DEBUG,
                  ACE_TEXT("(%P|%t) TransportClient::disassociate: ")
                  ACE_TEXT("no link for remote peer %C\n"),
                  log.c_str()));
     }
 
     return;
   }
 
   const DataLink_rch link = found->second;
 
   //now that an _rch is created for the link, remove the iterator from data_link_index_ while still holding lock
   //otherwise it could be removed in transport_detached()
   data_link_index_.erase(found);
   DataLinkSetMap released;
 
   if (DCPS_debug_level > 4) {
     ACE_DEBUG((LM_DEBUG,
                ACE_TEXT("(%P|%t) TransportClient::disassociate: ")
                ACE_TEXT("about to release_reservations for link[%@]\n"),
                link.in()));
   }
 
   link->release_reservations(peerId, repo_id_, released);
 
   if (!released.empty()) {
 
     if (DCPS_debug_level > 4) {
       ACE_DEBUG((LM_DEBUG,
                  ACE_TEXT("(%P|%t) TransportClient::disassociate: ")
                  ACE_TEXT("about to remove_link[%@] from links_\n"),
                  link.in()));
     }
     links_.remove_link(link);
 
     if (DCPS_debug_level > 4) {
       LogGuid logger(repo_id_);
       ACE_DEBUG((LM_DEBUG,
                  ACE_TEXT("(%P|%t) TransportClient::disassociate: calling remove_listener %C on link[%@]\n"),
                  logger.c_str(),
                  link.in()));
     }
     // Datalink is no longer used for any remote peer by this TransportClient
     link->remove_listener(repo_id_);
 
   }
 }

◆ domain_id()

virtual DDS::DomainId_t OpenDDS::DCPS::TransportClient::domain_id ( ) const

privatepure virtual

Implemented in OpenDDS::DCPS::DataReaderImpl, OpenDDS::DCPS::DataWriterImpl, OpenDDS::RTPS::Sedp::Endpoint, OpenDDS::DCPS::ReplayerImpl, and OpenDDS::DCPS::RecorderImpl.

Referenced by enable_transport().

◆ enable_transport()

void OpenDDS::DCPS::TransportClient::enable_transport	(	bool	reliable,
		bool	durable
	)

Definition at line 84 of file TransportClient.cpp.

References ACE_ERROR, ACE_TEXT(), OpenDDS::DCPS::TransportRegistry::DEFAULT_CONFIG_NAME, OpenDDS::DCPS::TransportRegistry::domain_default_config(), domain_id(), enable_transport_using_config(), OpenDDS::DCPS::TransportRegistry::fix_empty_default(), OpenDDS::DCPS::TransportRegistry::global_config(), OpenDDS::DCPS::TransportRegistry::instance(), OpenDDS::DCPS::TransportConfig::instances_, OpenDDS::DCPS::RcHandle< T >::is_nil(), LM_ERROR, OpenDDS::DCPS::TransportConfig::name(), and OpenDDS::DCPS::rchandle_from().

Referenced by OpenDDS::DCPS::RecorderImpl::enable(), OpenDDS::DCPS::ReplayerImpl::enable(), OpenDDS::DCPS::DataWriterImpl::enable(), and OpenDDS::DCPS::DataReaderImpl::enable().

 {
   // Search for a TransportConfig to use:
   TransportConfig_rch tc;
 
   // 1. If this object is an Entity, check if a TransportConfig has been
   //    bound either directly to this entity or to a parent entity.
   for (RcHandle<EntityImpl> ent = rchandle_from(dynamic_cast<EntityImpl*>(this));
        ent && tc.is_nil(); ent = ent->parent()) {
     tc = ent->transport_config();
   }
 
   if (tc.is_nil()) {
     TransportRegistry* const reg = TransportRegistry::instance();
     // 2. Check for a TransportConfig that is the default for this Domain.
     tc = reg->domain_default_config(domain_id());
 
     if (tc.is_nil()) {
       // 3. Use the global_config if one has been set.
       tc = reg->global_config();
 
       if (!tc.is_nil() && tc->instances_.empty()
           && tc->name() == TransportRegistry::DEFAULT_CONFIG_NAME) {
         // 4. Set the "fallback option" if the global_config is empty.
         //    (only applies if the user hasn't changed the global config)
         tc = reg->fix_empty_default();
       }
     }
   }
 
   if (tc.is_nil()) {
     ACE_ERROR((LM_ERROR,
                ACE_TEXT("(%P|%t) ERROR: TransportClient::enable_transport ")
                ACE_TEXT("No TransportConfig found.\n")));
     throw Transport::NotConfigured();
   }
 
   enable_transport_using_config(reliable, durable, tc);
 }

◆ enable_transport_using_config()

void OpenDDS::DCPS::TransportClient::enable_transport_using_config	(	bool	reliable,
		bool	durable,
		const TransportConfig_rch &	tc
	)

Definition at line 125 of file TransportClient.cpp.

References ACE_DEBUG, ACE_ERROR, ACE_TEXT(), cdr_encapsulation_, check_transport_qos(), config_, OpenDDS::DCPS::DCPS_debug_level, OpenDDS::DCPS::TransportConfig::DEFAULT_PASSIVE_CONNECT_DURATION, durable_, OpenDDS::DCPS::TimeDuration::from_msec(), get_crypto_handle(), OpenDDS::DCPS::TransportInst::get_or_create_impl(), impls_, OpenDDS::DCPS::TransportConfig::instances_, LM_ERROR, LM_WARNING, OpenDDS::DCPS::TransportImpl::local_crypto_handle(), OpenDDS::DCPS::TransportConfig::passive_connect_duration_, passive_connect_duration_, populate_connection_info(), reliable_, OpenDDS::DCPS::TransportInst::requires_cdr_encapsulation(), OpenDDS::DCPS::TransportConfig::swap_bytes_, and swap_bytes_.

Referenced by enable_transport(), OpenDDS::RTPS::Sedp::Endpoint::get_priority_value(), and OpenDDS::RTPS::Sedp::init().

 {
   config_ = tc;
   swap_bytes_ = tc->swap_bytes_;
   reliable_ = reliable;
   durable_ = durable;
   unsigned long duration = tc->passive_connect_duration_;
   if (duration == 0) {
     duration = TransportConfig::DEFAULT_PASSIVE_CONNECT_DURATION;
     if (DCPS_debug_level) {
       ACE_DEBUG((LM_WARNING,
         ACE_TEXT("(%P|%t) TransportClient::enable_transport_using_config ")
         ACE_TEXT("passive_connect_duration_ configured as 0, changing to ")
         ACE_TEXT("default value\n")));
     }
   }
   passive_connect_duration_ = TimeDuration::from_msec(duration);
 
   populate_connection_info();
 
   const size_t n = tc->instances_.size();
 
   for (size_t i = 0; i < n; ++i) {
     TransportInst_rch inst = tc->instances_[i];
 
     if (check_transport_qos(*inst)) {
       TransportImpl_rch impl = inst->get_or_create_impl();
 
       if (impl) {
         impls_.push_back(impl);
 
 #if defined(OPENDDS_SECURITY)
         impl->local_crypto_handle(get_crypto_handle());
 #endif
 
         cdr_encapsulation_ |= inst->requires_cdr_encapsulation();
       }
     }
   }
 
   if (impls_.empty()) {
     ACE_ERROR((LM_ERROR,
                ACE_TEXT("(%P|%t) ERROR: TransportClient::enable_transport ")
                ACE_TEXT("No TransportImpl could be created.\n")));
     throw Transport::NotConfigured();
   }
 }

◆ get_builtin_subscriber_proxy()

virtual RcHandle<BitSubscriber> OpenDDS::DCPS::TransportClient::get_builtin_subscriber_proxy ( ) const

inlinevirtual

Reimplemented in OpenDDS::DCPS::DataReaderImpl, OpenDDS::DCPS::DataWriterImpl, and OpenDDS::RTPS::Sedp::Endpoint.

Definition at line 132 of file TransportClient.h.

132 { return RcHandle<BitSubscriber>(); }

◆ get_crypto_handle()

virtual DDS::Security::ParticipantCryptoHandle OpenDDS::DCPS::TransportClient::get_crypto_handle ( ) const

inlineprivatevirtual

Reimplemented in OpenDDS::DCPS::DataReaderImpl, OpenDDS::DCPS::DataWriterImpl, and OpenDDS::RTPS::Sedp::Endpoint.

Definition at line 167 of file TransportClient.h.

References DDS::HANDLE_NIL.

Referenced by enable_transport_using_config().

   {
     return DDS::HANDLE_NIL;
   }

◆ get_guid()

virtual GUID_t OpenDDS::DCPS::TransportClient::get_guid ( ) const

pure virtual

Implemented in OpenDDS::DCPS::DataReaderImpl, OpenDDS::DCPS::DataWriterImpl, OpenDDS::RTPS::Sedp::Endpoint, OpenDDS::DCPS::ReplayerImpl, and OpenDDS::DCPS::RecorderImpl.

Referenced by associate(), is_leading(), and send_final_acks().

◆ get_ice_endpoint()

WeakRcHandle< ICE::Endpoint > OpenDDS::DCPS::TransportClient::get_ice_endpoint ( )

Definition at line 872 of file TransportClient.cpp.

References ACE_GUARD_RETURN, OpenDDS::DCPS::TransportImpl::get_ice_endpoint(), impls_, and lock_.

Referenced by OpenDDS::DCPS::DataWriterImpl::get_ice_endpoint(), OpenDDS::DCPS::DataReaderImpl::get_ice_endpoint(), and OpenDDS::RTPS::Sedp::DiscoveryWriter::write_dcps_participant_secure().

 {
   // The one-to-many relationship with impls implies that this should
   // return a set of endpoints instead of a single endpoint or null.
   // For now, we will assume a single impl.
 
   ACE_GUARD_RETURN(ACE_Thread_Mutex, guard, lock_, WeakRcHandle<ICE::Endpoint>());
   for (ImplsType::iterator pos = impls_.begin(), limit = impls_.end();
        pos != limit;
        ++pos) {
     TransportImpl_rch impl = pos->lock();
     if (impl) {
       WeakRcHandle<ICE::Endpoint> endpoint = impl->get_ice_endpoint();
       if (endpoint) { return endpoint; }
     }
   }
 
   return WeakRcHandle<ICE::Endpoint>();
 }

◆ get_max_sn()

virtual SequenceNumber OpenDDS::DCPS::TransportClient::get_max_sn ( ) const

inlineprivatevirtual

Reimplemented in OpenDDS::DCPS::DataWriterImpl, and OpenDDS::DCPS::ReplayerImpl.

Definition at line 162 of file TransportClient.h.

References OpenDDS::DCPS::SequenceNumber::SEQUENCENUMBER_UNKNOWN().

Referenced by associate().

162 { return SequenceNumber::SEQUENCENUMBER_UNKNOWN(); };

OpenDDS::DCPS::SequenceNumber::SEQUENCENUMBER_UNKNOWN

static SequenceNumber SEQUENCENUMBER_UNKNOWN()

Definition: SequenceNumber.h:129

◆ get_priority_value()

virtual Priority OpenDDS::DCPS::TransportClient::get_priority_value ( const AssociationData & data ) const

privatepure virtual

Implemented in OpenDDS::DCPS::DataReaderImpl, OpenDDS::DCPS::DataWriterImpl, OpenDDS::RTPS::Sedp::Endpoint, OpenDDS::DCPS::ReplayerImpl, and OpenDDS::DCPS::RecorderImpl.

Referenced by associate().

◆ get_receive_listener()

TransportReceiveListener_rch OpenDDS::DCPS::TransportClient::get_receive_listener ( )

private

Definition at line 1106 of file TransportClient.cpp.

References OpenDDS::DCPS::rchandle_from().

Referenced by add_link().

 {
   return rchandle_from(dynamic_cast<TransportReceiveListener*>(this));
 }

◆ get_send_listener()

TransportSendListener_rch OpenDDS::DCPS::TransportClient::get_send_listener ( )

private

Definition at line 1100 of file TransportClient.cpp.

References OpenDDS::DCPS::rchandle_from().

Referenced by add_link(), data_acked(), send_control(), and send_control_to().

 {
   return rchandle_from(dynamic_cast<TransportSendListener*>(this));
 }

◆ initiate_connect_i()

bool OpenDDS::DCPS::TransportClient::initiate_connect_i	(	TransportImpl::AcceptConnectResult &	result,
		TransportImpl_rch	impl,
		const TransportImpl::RemoteTransport &	remote,
		const TransportImpl::ConnectionAttribs &	attribs_,
		Guard &	guard
	)

private

Definition at line 384 of file TransportClient.cpp.

References ACE_DEBUG, ACE_GUARD_RETURN, ACE_TEXT(), OpenDDS::DCPS::LogGuid::c_str(), OpenDDS::DCPS::TransportImpl::connect_datalink(), OpenDDS::DCPS::DCPS_debug_level, LM_DEBUG, ACE_Guard< ACE_LOCK >::locked(), OpenDDS::DCPS::rchandle_from(), OpenDDS::DCPS::TransportImpl::RemoteTransport::repo_id_, repo_id_, reverse_lock_, OpenDDS::DCPS::TransportImpl::AcceptConnectResult::success_, and VDBG_LVL.

Referenced by OpenDDS::DCPS::TransportClient::PendingAssoc::initiate_connect().

 {
   if (!guard.locked()) {
     //don't own the lock_ so can't release it...shouldn't happen
     LogGuid local_log(repo_id_);
     LogGuid remote_log(remote.repo_id_);
     VDBG_LVL((LM_DEBUG, ACE_TEXT("(%P|%t) TransportClient::initiate_connect_i ")
                         ACE_TEXT("between local %C and remote %C unsuccessful because ")
                         ACE_TEXT("guard was not locked\n"),
                         local_log.c_str(),
                         remote_log.c_str()), 0);
     return false;
   }
 
   {
     //can't call connect while holding lock due to possible reactor deadlock
     LogGuid local_log(repo_id_);
     LogGuid remote_log(remote.repo_id_);
     VDBG_LVL((LM_DEBUG, "(%P|%t) TransportClient::initiate_connect_i - "
                         "attempt to connect_datalink between local %C and remote %C\n",
                         local_log.c_str(),
                         remote_log.c_str()), 0);
     {
       TransportImpl::ConnectionAttribs attribs = attribs_;
       RcHandle<TransportClient> client = rchandle_from(this);
       ACE_GUARD_RETURN(Reverse_Lock_t, unlock_guard, reverse_lock_, false);
       result = impl->connect_datalink(remote, attribs, client);
     }
     if (!result.success_) {
       if (DCPS_debug_level) {
         LogGuid writer_log(repo_id_);
         LogGuid reader_log(remote.repo_id_);
         ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) TransportClient::initiate_connect_i - ")
                    ACE_TEXT("connect_datalink between local %C remote %C not successful\n"),
                    writer_log.c_str(),
                    reader_log.c_str()));
       }
       return false;
     }
   }
 
   LogGuid local_log(repo_id_);
   LogGuid remote_log(remote.repo_id_);
   VDBG_LVL((LM_DEBUG, "(%P|%t) TransportClient::initiate_connect_i - "
                       "connection between local %C and remote %C initiation successful\n",
                       local_log.c_str(),
                       remote_log.c_str()), 0);
   return true;
 }

◆ is_leading()

bool OpenDDS::DCPS::TransportClient::is_leading ( const GUID_t & reader_id ) const

Definition at line 1191 of file TransportClient.cpp.

References get_guid(), OpenDDS::DCPS::DataLinkSet::is_leading(), links_, and OPENDDS_END_VERSIONED_NAMESPACE_DECL.

 {
   return links_.is_leading(get_guid(), reader_id);
 }

◆ is_reliable()

bool OpenDDS::DCPS::TransportClient::is_reliable ( ) const

inline

Definition at line 70 of file TransportClient.h.

References header, and send().

70 { return reliable_; }

OpenDDS::DCPS::TransportClient::reliable_

bool reliable_

Definition: TransportClient.h:340

◆ OPENDDS_MAP_CMP() [1/2]

typedef OpenDDS::DCPS::TransportClient::OPENDDS_MAP_CMP	(	GUID_t	,
		DataLink_rch	,
		GUID_tKeyLessThan
	)

private

Referenced by OpenDDS::RTPS::Sedp::ignore().

◆ OPENDDS_MAP_CMP() [2/2]

typedef OpenDDS::DCPS::TransportClient::OPENDDS_MAP_CMP	(	GUID_t	,
		PendingAssoc_rch	,
		GUID_tKeyLessThan
	)

private

◆ OPENDDS_MULTIMAP_CMP()

typedef OpenDDS::DCPS::TransportClient::OPENDDS_MULTIMAP_CMP	(	GUID_t	,
		PendingAssoc_rch	,
		GUID_tKeyLessThan
	)

private

◆ OPENDDS_VECTOR()

typedef OpenDDS::DCPS::TransportClient::OPENDDS_VECTOR ( WeakRcHandle< TransportImpl > )

private

Referenced by OpenDDS::DCPS::RecorderImpl::signal_liveliness().

◆ pending_association_with()

bool OpenDDS::DCPS::TransportClient::pending_association_with ( const GUID_t & remote ) const

Definition at line 1165 of file TransportClient.cpp.

References ACE_ERROR, LM_ERROR, lock_, ACE_Guard< ACE_LOCK >::locked(), and pending_.

 {
   ACE_Guard<ACE_Thread_Mutex> guard(lock_);
   if (!guard.locked()) {
     ACE_ERROR((LM_ERROR, "(%P|%t) ERROR: TransportClient::pending_association_with: "
       "lock failed\n"));
     return false;
   }
   return pending_.count(remote);
 }

◆ populate_connection_info()

void OpenDDS::DCPS::TransportClient::populate_connection_info ( )

Definition at line 175 of file TransportClient.cpp.

References ACE_ERROR, ACE_TEXT(), check_transport_qos(), config_, conn_info_, OpenDDS::DCPS::TransportImpl::connection_info(), OpenDDS::DCPS::CONNINFO_ALL, OpenDDS::DCPS::TransportInst::get_or_create_impl(), OpenDDS::DCPS::grow(), OpenDDS::DCPS::TransportConfig::instances_, and LM_ERROR.

Referenced by enable_transport_using_config(), and OpenDDS::DCPS::DataWriterImpl::transport_discovery_change().

 {
   conn_info_.length(0);
 
   const size_t n = config_->instances_.size();
   for (size_t i = 0; i < n; ++i) {
     TransportInst_rch inst = config_->instances_[i];
     if (check_transport_qos(*inst)) {
       TransportImpl_rch impl = inst->get_or_create_impl();
       if (impl) {
         const CORBA::ULong idx = DCPS::grow(conn_info_) - 1;
         impl->connection_info(conn_info_[idx], CONNINFO_ALL);
       }
     }
   }
 
   if (conn_info_.length() == 0) {
     ACE_ERROR((LM_ERROR,
                ACE_TEXT("(%P|%t) TransportClient::populate_connection_info: ")
                ACE_TEXT("No connection info\n")));
   }
 }

◆ register_for_reader()

void OpenDDS::DCPS::TransportClient::register_for_reader	(	const GUID_t &	participant,
		const GUID_t &	writerid,
		const GUID_t &	readerid,
		const TransportLocatorSeq &	locators,
		OpenDDS::DCPS::DiscoveryListener *	listener
	)

Definition at line 789 of file TransportClient.cpp.

References ACE_GUARD, impls_, lock_, and OpenDDS::DCPS::TransportImpl::register_for_reader().

Referenced by OpenDDS::DCPS::ReplayerImpl::register_for_reader(), and OpenDDS::DCPS::DataWriterImpl::register_for_reader().

 {
   ACE_GUARD(ACE_Thread_Mutex, guard, lock_);
   for (ImplsType::iterator pos = impls_.begin(), limit = impls_.end();
        pos != limit;
        ++pos) {
     TransportImpl_rch impl = pos->lock();
     if (impl) {
       impl->register_for_reader(participant, writerid, readerid, locators, listener);
     }
   }
 }

◆ register_for_writer()

void OpenDDS::DCPS::TransportClient::register_for_writer	(	const GUID_t &	participant,
		const GUID_t &	readerid,
		const GUID_t &	writerid,
		const TransportLocatorSeq &	locators,
		DiscoveryListener *	listener
	)

Definition at line 823 of file TransportClient.cpp.

References ACE_GUARD, impls_, lock_, and OpenDDS::DCPS::TransportImpl::register_for_writer().

Referenced by OpenDDS::DCPS::RecorderImpl::register_for_writer(), and OpenDDS::DCPS::DataReaderImpl::register_for_writer().

 {
   ACE_GUARD(ACE_Thread_Mutex, guard, lock_);
   for (ImplsType::iterator pos = impls_.begin(), limit = impls_.end();
        pos != limit;
        ++pos) {
     TransportImpl_rch impl = pos->lock();
     if (impl) {
       impl->register_for_writer(participant, readerid, writerid, locators, listener);
     }
   }
 }

◆ remove_all_msgs()

bool OpenDDS::DCPS::TransportClient::remove_all_msgs ( )

Definition at line 1144 of file TransportClient.cpp.

References links_, OpenDDS::DCPS::DataLinkSet::remove_all_msgs(), and repo_id_.

Referenced by OpenDDS::DCPS::WriteDataContainer::unregister_all().

 {
   return links_.remove_all_msgs(repo_id_);
 }

◆ remove_sample()

bool OpenDDS::DCPS::TransportClient::remove_sample ( const DataSampleElement * sample )

Definition at line 1138 of file TransportClient.cpp.

References links_, and OpenDDS::DCPS::DataLinkSet::remove_sample().

Referenced by OpenDDS::DCPS::WriteDataContainer::remove_oldest_sample().

 {
   return links_.remove_sample(sample);
 }

◆ repo_id()

GUID_t OpenDDS::DCPS::TransportClient::repo_id ( ) const

inline

Definition at line 139 of file TransportClient.h.

References lock_.

Referenced by associate(), OpenDDS::DCPS::DataReaderImpl::data_received(), send_i(), transport_stop(), and OpenDDS::DCPS::ReplayerImpl::write().

   {
     ACE_Guard<ACE_Thread_Mutex> guard(lock_);
     return repo_id_;
   }

◆ send()

void OpenDDS::DCPS::TransportClient::send	(	SendStateDataSampleList	send_list,
		ACE_UINT64	transaction_id = `0`
	)

Definition at line 919 of file TransportClient.cpp.

References ACE_GUARD, OpenDDS::DCPS::SendStateDataSampleList::head(), send_i(), and send_transaction_lock_.

Referenced by OpenDDS::DCPS::DataWriterImpl::send_all_to_flush_control(), OpenDDS::RTPS::Sedp::Writer::send_sample_i(), OpenDDS::DCPS::DataWriterImpl::send_suspended_data(), OpenDDS::DCPS::ReplayerImpl::write(), and OpenDDS::DCPS::DataWriterImpl::write().

 {
   if (send_list.head() == 0) {
     return;
   }
   ACE_GUARD(ACE_Thread_Mutex, send_transaction_guard, send_transaction_lock_);
   send_i(send_list, transaction_id);
 }

◆ send_control()

SendControlStatus OpenDDS::DCPS::TransportClient::send_control	(	const DataSampleHeader &	header,
		Message_Block_Ptr	msg
	)

Definition at line 1112 of file TransportClient.cpp.

References get_send_listener(), links_, OpenDDS::DCPS::move(), repo_id_, and OpenDDS::DCPS::DataLinkSet::send_control().

Referenced by OpenDDS::DCPS::DataWriterImpl::send_control(), and OpenDDS::RTPS::Sedp::Writer::write_control_msg().

 {
   return links_.send_control(repo_id_, get_send_listener(), header, move(msg));
 }

◆ send_control_to()

SendControlStatus OpenDDS::DCPS::TransportClient::send_control_to	(	const DataSampleHeader &	header,
		Message_Block_Ptr	msg,
		const GUID_t &	destination
	)

Definition at line 1119 of file TransportClient.cpp.

References ACE_GUARD_RETURN, data_link_index_, get_send_listener(), OpenDDS::DCPS::DataLinkSet::insert_link(), lock_, OpenDDS::DCPS::move(), repo_id_, OpenDDS::DCPS::DataLinkSet::send_control(), and OpenDDS::DCPS::SEND_CONTROL_ERROR.

Referenced by send_w_control().

 {
   DataLinkSet singular;
   {
     ACE_GUARD_RETURN(ACE_Thread_Mutex, guard, lock_, SEND_CONTROL_ERROR);
     DataLinkIndex::iterator found = data_link_index_.find(destination);
 
     if (found == data_link_index_.end()) {
       return SEND_CONTROL_ERROR;
     }
 
     singular.insert_link(found->second);
   }
   return singular.send_control(repo_id_, get_send_listener(), header, move(msg));
 }

◆ send_final_acks()

void OpenDDS::DCPS::TransportClient::send_final_acks ( )

Definition at line 685 of file TransportClient.cpp.

References get_guid(), links_, and OpenDDS::DCPS::DataLinkSet::send_final_acks().

 {
   links_.send_final_acks(get_guid());
 }

◆ send_i()

void OpenDDS::DCPS::TransportClient::send_i	(	SendStateDataSampleList	send_list,
		ACE_UINT64	transaction_id
	)

private

Definition at line 943 of file TransportClient.cpp.

Referenced by send(), and send_w_control().

 {
   if (transaction_id != 0 && transaction_id != expected_transaction_id_) {
     if (transaction_id > max_transaction_id_seen_) {
       max_transaction_id_seen_ = transaction_id;
       max_transaction_tail_ = send_list.tail();
     }
     return;
   } else /* transaction_id == expected_transaction_id */ {
 
     DataSampleElement* cur = send_list.head();
     if (max_transaction_tail_ == 0) {
       //Means no future transaction beat this transaction into send
       if (transaction_id != 0)
         max_transaction_id_seen_ = expected_transaction_id_;
       // Only send this current transaction
       max_transaction_tail_ = send_list.tail();
     }
     DataLinkSet send_links;
 
     while (cur != 0) {
       // VERY IMPORTANT NOTE:
       //
       // We have to be very careful in how we deal with the current
       // DataSampleElement.  The issue is that once we have invoked
       // data_delivered() on the send_listener_ object, or we have invoked
       // send() on the pub_links, we can no longer access the current
       // DataSampleElement!Thus, we need to get the next
       // DataSampleElement (pointer) from the current element now,
       // while it is safe.
       DataSampleElement* next_elem;
       if (cur != max_transaction_tail_) {
         next_elem = cur->get_next_send_sample();
       } else {
         next_elem = max_transaction_tail_;
       }
       DataLinkSet_rch pub_links =
         (cur->get_num_subs() > 0)
         ? DataLinkSet_rch(links_.select_links(cur->get_sub_ids(), cur->get_num_subs()))
         : DataLinkSet_rch(&links_, inc_count());
 
       if (pub_links.is_nil() || pub_links->empty()) {
         // NOTE: This is the "local publisher id is not currently
         //       associated with any remote subscriber ids" case.
 
         if (DCPS_debug_level > 4) {
           LogGuid logger(cur->get_pub_id());
           ACE_DEBUG((LM_DEBUG,
                      ACE_TEXT("(%P|%t) TransportClient::send_i: ")
                      ACE_TEXT("no links for publication %C, ")
                      ACE_TEXT("not sending element %@ for transaction: %d.\n"),
                      logger.c_str(),
                      cur,
                      cur->transaction_id()));
         }
 
         // We tell the send_listener_ that all of the remote subscriber ids
         // that wanted the data (all zero of them) have indeed received
         // the data.
         cur->get_send_listener()->data_delivered(cur);
 
       } else {
         VDBG_LVL((LM_DEBUG,"(%P|%t) DBG: Found DataLinkSet. Sending element %@.\n"
                   , cur), 5);
 
 #ifndef OPENDDS_NO_CONTENT_SUBSCRIPTION_PROFILE
 
         // Content-Filtering adjustment to the pub_links:
         // - If the sample should be filtered out of all subscriptions on a given
         //   DataLink, then exclude that link from the subset that we'll send to.
         // - If the sample should be filtered out of some (or none) of the subs,
         //   then record that information in the DataSampleElement so that the
         //   header's content_filter_entries_ can be marshaled before it's sent.
         if (cur->filter_out_.ptr()) {
           DataLinkSet_rch subset;
           DataLinkSet::GuardType guard(pub_links->lock());
           typedef DataLinkSet::MapType MapType;
           MapType& map = pub_links->map();
 
           for (MapType::iterator itr = map.begin(); itr != map.end(); ++itr) {
             size_t n_subs;
             GUIDSeq_var ti =
               itr->second->target_intersection(cur->get_pub_id(),
                                                cur->filter_out_.in(), n_subs);
 
             if (ti.ptr() == 0 || ti->length() != n_subs) {
               if (!subset.in()) {
                 subset = make_rch<DataLinkSet>();
               }
 
               subset->insert_link(itr->second);
               cur->filter_per_link_[itr->first] = ti._retn();
 
             } else {
               VDBG((LM_DEBUG,
                     "(%P|%t) DBG: DataLink completely filtered-out %@.\n",
                     itr->second.in()));
             }
           }
 
           if (!subset.in()) {
             guard.release();
             VDBG((LM_DEBUG, "(%P|%t) DBG: filtered-out of all DataLinks.\n"));
             // similar to the "if (pub_links.is_nil())" case above, no links
             cur->get_send_listener()->data_delivered(cur);
             if (cur != max_transaction_tail_) {
               // Move on to the next DataSampleElement to send.
               cur = next_elem;
               continue;
             } else {
               break;
             }
           }
 
           pub_links = subset;
         }
 
 #endif
 
         // This will do several things, including adding to the membership
         // of the send_links set.  Any DataLinks added to the send_links
         // set will be also told about the send_start() event.  Those
         // DataLinks (in the pub_links set) that are already in the
         // send_links set will not be told about the send_start() event
         // since they heard about it when they were inserted into the
         // send_links set.
         send_links.send_start(pub_links.in());
         if (cur->get_header().message_id_ != SAMPLE_DATA) {
           pub_links->send_control(cur);
         } else {
           pub_links->send(cur);
         }
       }
       if (cur != max_transaction_tail_) {
         // Move on to the next DataSampleElement to send.
         cur = next_elem;
       } else {
         break;
       }
     }
 
     // This will inform each DataLink in the set about the stop_send() event.
     // It will then clear the send_links_ set.
     //
     // The reason that the send_links_ set is cleared is because we continually
     // reuse the same send_links_ object over and over for each call to this
     // send method.
     GUID_t pub_id = repo_id();
     send_links.send_stop(pub_id);
     if (transaction_id != 0) {
       expected_transaction_id_ = max_transaction_id_seen_ + 1;
     }
     max_transaction_tail_ = 0;
   }
 }

◆ send_response()

bool OpenDDS::DCPS::TransportClient::send_response	(	const GUID_t &	peer,
		const DataSampleHeader &	header,
		Message_Block_Ptr	payload
	)

Definition at line 893 of file TransportClient.cpp.

References ACE_DEBUG, ACE_TEXT(), OpenDDS::DCPS::LogGuid::c_str(), data_link_index_, OpenDDS::DCPS::DCPS_debug_level, OpenDDS::DCPS::DataLinkSet::insert_link(), LM_DEBUG, OpenDDS::DCPS::move(), and OpenDDS::DCPS::DataLinkSet::send_response().

 {
   DataLinkIndex::iterator found = data_link_index_.find(peer);
 
   if (found == data_link_index_.end()) {
     if (DCPS_debug_level > 4) {
       LogGuid logger(peer);
       ACE_DEBUG((LM_DEBUG,
                  ACE_TEXT("(%P|%t) TransportClient::send_response: ")
                  ACE_TEXT("no link for publication %C, ")
                  ACE_TEXT("not sending response.\n"),
                  logger.c_str()));
     }
 
     return false;
   }
 
   DataLinkSet singular;
   singular.insert_link(found->second);
   singular.send_response(peer, header, move(payload));
   return true;
 }

◆ send_w_control()

SendControlStatus OpenDDS::DCPS::TransportClient::send_w_control	(	SendStateDataSampleList	send_list,
		const DataSampleHeader &	header,
		Message_Block_Ptr	msg,
		const GUID_t &	destination
	)

Definition at line 929 of file TransportClient.cpp.

References ACE_GUARD_RETURN, OpenDDS::DCPS::SendStateDataSampleList::head(), OpenDDS::DCPS::move(), OpenDDS::DCPS::SEND_CONTROL_ERROR, send_control_to(), send_i(), and send_transaction_lock_.

Referenced by OpenDDS::DCPS::DataWriterImpl::association_complete_i(), and OpenDDS::DCPS::DataWriterImpl::replay_durable_data_for().

 {
   ACE_GUARD_RETURN(ACE_Thread_Mutex, send_transaction_guard,
                    send_transaction_lock_, SEND_CONTROL_ERROR);
   if (send_list.head()) {
     send_i(send_list, 0);
   }
   return send_control_to(header, move(msg), destination);
 }

◆ stop_associating() [1/2]

void OpenDDS::DCPS::TransportClient::stop_associating ( )

Definition at line 633 of file TransportClient.cpp.

References ACE_GUARD, lock_, pending_, pending_assoc_timer_, prev_pending_, and OpenDDS::DCPS::TransportImpl::stop_accepting_or_connecting().

Referenced by OpenDDS::DCPS::DataWriterImpl::prepare_to_delete(), OpenDDS::DCPS::ReplayerImpl::remove_all_associations(), OpenDDS::DCPS::DataWriterImpl::remove_all_associations(), OpenDDS::DCPS::DataReaderImpl::remove_all_associations(), OpenDDS::DCPS::RecorderImpl::remove_associations(), OpenDDS::DCPS::ReplayerImpl::remove_associations(), OpenDDS::DCPS::DataWriterImpl::remove_associations(), OpenDDS::DCPS::DataReaderImpl::remove_associations(), and ~TransportClient().

 {
   ACE_GUARD(ACE_Thread_Mutex, guard, lock_);
   for (PendingMap::iterator it = pending_.begin(); it != pending_.end(); ++it) {
     {
       // The transport impl may have resource for a pending connection.
       ACE_Guard<ACE_Thread_Mutex> guard(it->second->mutex_);
       for (size_t i = 0; i < it->second->impls_.size(); ++i) {
         TransportImpl_rch impl = it->second->impls_[i].lock();
         if (impl) {
           impl->stop_accepting_or_connecting(*this, it->second->data_.remote_id_, true, true);
         }
       }
     }
     it->second->reset_client();
     pending_assoc_timer_->cancel_timer(it->second);
     prev_pending_.insert(std::make_pair(it->first, it->second));
   }
   pending_.clear();
 }

◆ stop_associating() [2/2]

void OpenDDS::DCPS::TransportClient::stop_associating	(	const GUID_t *	repos,
		CORBA::ULong	length
	)

Definition at line 655 of file TransportClient.cpp.

References ACE_GUARD, lock_, pending_, pending_assoc_timer_, prev_pending_, and OpenDDS::DCPS::TransportImpl::stop_accepting_or_connecting().

 {
   ACE_GUARD(ACE_Thread_Mutex, guard, lock_);
 
   if (repos == 0 || length == 0) {
     return;
   } else {
     for (CORBA::ULong i = 0; i < length; ++i) {
       PendingMap::iterator iter = pending_.find(repos[i]);
       if (iter != pending_.end()) {
         {
           // The transport impl may have resource for a pending connection.
           ACE_Guard<ACE_Thread_Mutex> guard(iter->second->mutex_);
           for (size_t i = 0; i < iter->second->impls_.size(); ++i) {
             TransportImpl_rch impl = iter->second->impls_[i].lock();
             if (impl) {
               impl->stop_accepting_or_connecting(*this, iter->second->data_.remote_id_, true, true);
             }
           }
         }
         iter->second->reset_client();
         pending_assoc_timer_->cancel_timer(iter->second);
         prev_pending_.insert(std::make_pair(iter->first, iter->second));
         pending_.erase(iter);
       }
     }
   }
 }

◆ swap_bytes()

bool OpenDDS::DCPS::TransportClient::swap_bytes ( ) const

inline

Definition at line 66 of file TransportClient.h.

Referenced by OpenDDS::DCPS::DataWriterImpl::create_control_message(), OpenDDS::DCPS::DataWriterImpl::create_sample_data_message(), OpenDDS::DCPS::DataWriterImpl::end_coherent_changes(), and OpenDDS::DCPS::DataWriterImpl::setup_serialization().

66 { return swap_bytes_; }

OpenDDS::DCPS::TransportClient::swap_bytes_

bool swap_bytes_

Definition: TransportClient.h:340

◆ terminate_send_if_suspended()

void OpenDDS::DCPS::TransportClient::terminate_send_if_suspended ( )

Definition at line 1149 of file TransportClient.cpp.

References links_, and OpenDDS::DCPS::DataLinkSet::terminate_send_if_suspended().

Referenced by OpenDDS::DCPS::DataWriterImpl::prepare_to_delete().

 {
   links_.terminate_send_if_suspended();
 }

◆ transport_assoc_done()

virtual void OpenDDS::DCPS::TransportClient::transport_assoc_done	(	int	,
		const GUID_t &
	)

inlineprivatevirtual

Reimplemented in OpenDDS::RTPS::Sedp::Writer, OpenDDS::DCPS::DataReaderImpl, and OpenDDS::DCPS::DataWriterImpl.

Definition at line 161 of file TransportClient.h.

Referenced by use_datalink_i().

161 {}

◆ transport_stop()

void OpenDDS::DCPS::TransportClient::transport_stop ( )

Definition at line 773 of file TransportClient.cpp.

References ACE_GUARD, OpenDDS::DCPS::TransportImpl::client_stop(), impls_, lock_, repo_id(), and repo_id_.

Referenced by OpenDDS::DCPS::RecorderImpl::remove_all_associations(), OpenDDS::DCPS::ReplayerImpl::remove_all_associations(), OpenDDS::DCPS::DataWriterImpl::remove_all_associations(), and OpenDDS::DCPS::DataReaderImpl::remove_all_associations().

 {
   ACE_GUARD(ACE_Thread_Mutex, guard, lock_);
   const ImplsType impls = impls_;
   const GUID_t repo_id = repo_id_;
   guard.release();
 
   for (size_t i = 0; i < impls.size(); ++i) {
     const TransportImpl_rch impl = impls[i].lock();
     if (impl) {
       impl->client_stop(repo_id);
     }
   }
 }

◆ unregister_for_reader()

void OpenDDS::DCPS::TransportClient::unregister_for_reader	(	const GUID_t &	participant,
		const GUID_t &	writerid,
		const GUID_t &	readerid
	)

Definition at line 807 of file TransportClient.cpp.

References ACE_GUARD, impls_, lock_, and OpenDDS::DCPS::TransportImpl::unregister_for_reader().

Referenced by OpenDDS::DCPS::ReplayerImpl::unregister_for_reader(), and OpenDDS::DCPS::DataWriterImpl::unregister_for_reader().

 {
   ACE_GUARD(ACE_Thread_Mutex, guard, lock_);
   for (ImplsType::iterator pos = impls_.begin(), limit = impls_.end();
        pos != limit;
        ++pos) {
     TransportImpl_rch impl = pos->lock();
     if (impl) {
       impl->unregister_for_reader(participant, writerid, readerid);
     }
   }
 }

◆ unregister_for_writer()

void OpenDDS::DCPS::TransportClient::unregister_for_writer	(	const GUID_t &	participant,
		const GUID_t &	readerid,
		const GUID_t &	writerid
	)

Definition at line 841 of file TransportClient.cpp.

References ACE_GUARD, impls_, lock_, and OpenDDS::DCPS::TransportImpl::unregister_for_writer().

Referenced by OpenDDS::DCPS::RecorderImpl::unregister_for_writer(), and OpenDDS::DCPS::DataReaderImpl::unregister_for_writer().

 {
   ACE_GUARD(ACE_Thread_Mutex, guard, lock_);
   for (ImplsType::iterator pos = impls_.begin(), limit = impls_.end();
        pos != limit;
        ++pos) {
     TransportImpl_rch impl = pos->lock();
     if (impl) {
       impl->unregister_for_writer(participant, readerid, writerid);
     }
   }
 }

◆ update_locators()

void OpenDDS::DCPS::TransportClient::update_locators	(	const GUID_t &	remote,
		const TransportLocatorSeq &	locators
	)

Definition at line 857 of file TransportClient.cpp.

References ACE_GUARD, impls_, lock_, and OpenDDS::DCPS::TransportImpl::update_locators().

Referenced by OpenDDS::DCPS::DataWriterImpl::update_locators(), and OpenDDS::DCPS::DataReaderImpl::update_locators().

 {
   ACE_GUARD(ACE_Thread_Mutex, guard, lock_);
   for (ImplsType::iterator pos = impls_.begin(), limit = impls_.end();
        pos != limit;
        ++pos) {
     TransportImpl_rch impl = pos->lock();
     if (impl) {
       impl->update_locators(remote, locators);
     }
   }
 }

◆ use_datalink()

void OpenDDS::DCPS::TransportClient::use_datalink	(	const GUID_t &	remote_id,
		const DataLink_rch &	link
	)

Definition at line 526 of file TransportClient.cpp.

References ACE_GUARD, lock_, and use_datalink_i().

 {
   ACE_GUARD(ACE_Thread_Mutex, guard, lock_);
 
   use_datalink_i(remote_id, link, guard);
 }

◆ use_datalink_i()

void OpenDDS::DCPS::TransportClient::use_datalink_i	(	const GUID_t &	remote_id,
		const DataLink_rch &	link,
		Guard &	guard
	)

private

Definition at line 535 of file TransportClient.cpp.

References ACE_GUARD, OpenDDS::DCPS::TransportClient::PendingAssoc::active_, add_link(), ASSOC_ACTIVE, ASSOC_OK, OpenDDS::DCPS::LogGuid::c_str(), OpenDDS::DCPS::TransportClient::PendingAssoc::data_, OpenDDS::DCPS::TransportClient::PendingAssoc::impls_, OpenDDS::DCPS::RcHandle< T >::in(), OpenDDS::DCPS::TransportClient::PendingAssoc::initiate_connect(), OpenDDS::DCPS::RcHandle< T >::is_nil(), LM_DEBUG, OpenDDS::DCPS::TransportClient::PendingAssoc::mutex_, pending_, pending_assoc_timer_, prev_pending_, ACE_Guard< ACE_LOCK >::release(), OpenDDS::DCPS::AssociationData::remote_id_, OpenDDS::DCPS::TransportClient::PendingAssoc::reset_client(), OpenDDS::DCPS::TransportImpl::stop_accepting_or_connecting(), transport_assoc_done(), and VDBG_LVL.

Referenced by associate(), OpenDDS::DCPS::TransportClient::PendingAssoc::initiate_connect(), and use_datalink().

 {
   // Try to make a local copy of remote_id to use in calls
   // because the reference could be invalidated if the caller
   // reference location is deleted (i.e. in stop_accepting_or_connecting
   // if use_datalink_i was called from passive_connection)
   // Does changing this from a reference to a local affect anything going forward?
   GUID_t remote_id(remote_id_ref);
 
   LogGuid peerId_log(remote_id);
   VDBG_LVL((LM_DEBUG, "(%P|%t) TransportClient::use_datalink_i "
             "TransportClient(%@) using datalink[%@] from %C\n",
             this,
             link.in(),
             peerId_log.c_str()), 0);
 
   PendingMap::iterator iter = pending_.find(remote_id);
 
   if (iter == pending_.end()) {
     VDBG_LVL((LM_DEBUG, "(%P|%t) TransportClient::use_datalink_i "
                         "TransportClient(%@) using datalink[%@] did not find Pending Association to remote %C\n",
                         this,
                         link.in(),
                         peerId_log.c_str()), 0);
     return;
   }
 
   PendingAssoc_rch pend = iter->second;
   ACE_GUARD(ACE_Thread_Mutex, pend_guard, pend->mutex_);
   const int active_flag = pend->active_ ? ASSOC_ACTIVE : 0;
   bool ok = false;
 
   if (link.is_nil()) {
 
     if (pend->active_ && pend->initiate_connect(this, guard)) {
       VDBG_LVL((LM_DEBUG, "(%P|%t) TransportClient::use_datalink_i "
                           "TransportClient(%@) using datalink[%@] link is nil, since this is active side, initiate_connect to remote %C\n",
                           this,
                           link.in(),
                           peerId_log.c_str()), 0);
       return;
     }
 
     VDBG_LVL((LM_DEBUG, "(%P|%t) TransportClient::use_datalink_i "
               "TransportClient(%@) using datalink[%@] link is nil, since this is passive side, connection to remote %C timed out\n",
               this,
               link.in(),
               peerId_log.c_str()), 0);
   } else { // link is ready to use
     VDBG_LVL((LM_DEBUG, "(%P|%t) TransportClient::use_datalink_i "
               "TransportClient(%@) about to add_link[%@] to remote: %C\n",
               this,
               link.in(),
               peerId_log.c_str()), 0);
 
     add_link(link, remote_id);
     ok = true;
   }
 
   // either link is valid or assoc failed, clean up pending object
   for (size_t i = 0; i < pend->impls_.size(); ++i) {
     TransportImpl_rch impl = pend->impls_[i].lock();
     if (impl) {
       impl->stop_accepting_or_connecting(*this, pend->data_.remote_id_, false, !ok);
     }
   }
 
   pend_guard.release();
   pend->reset_client();
   pending_assoc_timer_->cancel_timer(pend);
   prev_pending_.insert(std::make_pair(iter->first, iter->second));
   pending_.erase(iter);
 
   // Release TransportClient's lock as we're done updating its data.
   guard.release();
 
   transport_assoc_done(active_flag | (ok ? ASSOC_OK : 0), remote_id);
 }

Friends And Related Function Documentation

◆ ::DDS_TEST

friend class ::DDS_TEST

friend

Definition at line 194 of file TransportClient.h.

Member Data Documentation

◆ cdr_encapsulation_

bool OpenDDS::DCPS::TransportClient::cdr_encapsulation_

private

Definition at line 340 of file TransportClient.h.

Referenced by enable_transport_using_config().

◆ config_

TransportConfig_rch OpenDDS::DCPS::TransportClient::config_

private

Definition at line 316 of file TransportClient.h.

Referenced by enable_transport_using_config(), and populate_connection_info().

◆ conn_info_

TransportLocatorSeq OpenDDS::DCPS::TransportClient::conn_info_

private

Definition at line 344 of file TransportClient.h.

Referenced by populate_connection_info().

◆ data_link_index_

DataLinkIndex OpenDDS::DCPS::TransportClient::data_link_index_

private

Definition at line 322 of file TransportClient.h.

Referenced by add_link(), associated_with(), disassociate(), send_control_to(), and send_response().

◆ durable_

bool OpenDDS::DCPS::TransportClient::durable_

private

Definition at line 340 of file TransportClient.h.

Referenced by associate(), enable_transport_using_config(), and OpenDDS::DCPS::DataWriterImpl::ReaderInfo::ReaderInfo().

◆ expected_transaction_id_

ACE_UINT64 OpenDDS::DCPS::TransportClient::expected_transaction_id_

private

Definition at line 328 of file TransportClient.h.

Referenced by send_i().

◆ impls_

ImplsType OpenDDS::DCPS::TransportClient::impls_

private

Definition at line 317 of file TransportClient.h.

Referenced by associate(), enable_transport_using_config(), get_ice_endpoint(), OpenDDS::DCPS::TransportClient::PendingAssoc::initiate_connect(), register_for_reader(), register_for_writer(), transport_stop(), unregister_for_reader(), unregister_for_writer(), update_locators(), and ~TransportClient().

◆ links_

DataLinkSet OpenDDS::DCPS::TransportClient::links_

private

Definition at line 320 of file TransportClient.h.

Referenced by add_link(), disassociate(), is_leading(), remove_all_msgs(), remove_sample(), send_control(), send_final_acks(), send_i(), and terminate_send_if_suspended().

◆ lock_

ACE_Thread_Mutex OpenDDS::DCPS::TransportClient::lock_

mutableprivate

Seems to protect accesses to impls_, pending_, links_, data_link_index_.

Definition at line 347 of file TransportClient.h.

◆ max_transaction_id_seen_

ACE_UINT64 OpenDDS::DCPS::TransportClient::max_transaction_id_seen_

private

Definition at line 329 of file TransportClient.h.

Referenced by send_i().

◆ max_transaction_tail_

DataSampleElement* OpenDDS::DCPS::TransportClient::max_transaction_tail_

private

Definition at line 336 of file TransportClient.h.

Referenced by send_i().

◆ passive_connect_duration_

TimeDuration OpenDDS::DCPS::TransportClient::passive_connect_duration_

private

Definition at line 342 of file TransportClient.h.

Referenced by enable_transport_using_config().

◆ pending_

PendingMap OpenDDS::DCPS::TransportClient::pending_

private

Definition at line 318 of file TransportClient.h.

Referenced by associate(), disassociate(), pending_association_with(), stop_associating(), and use_datalink_i().

◆ pending_assoc_timer_

RcHandle<PendingAssocTimer> OpenDDS::DCPS::TransportClient::pending_assoc_timer_

private

Definition at line 312 of file TransportClient.h.

Referenced by associate(), disassociate(), stop_associating(), and use_datalink_i().

◆ prev_pending_

PrevPendingMap OpenDDS::DCPS::TransportClient::prev_pending_

private

Definition at line 319 of file TransportClient.h.

Referenced by clean_prev_pending(), disassociate(), stop_associating(), use_datalink_i(), and ~TransportClient().

◆ reliable_

bool OpenDDS::DCPS::TransportClient::reliable_

private

Definition at line 340 of file TransportClient.h.

Referenced by add_link(), associate(), and enable_transport_using_config().

◆ repo_id_

GUID_t OpenDDS::DCPS::TransportClient::repo_id_

private

Definition at line 351 of file TransportClient.h.

Referenced by add_link(), associate(), disassociate(), OpenDDS::DCPS::TransportClient::PendingAssoc::initiate_connect(), initiate_connect_i(), remove_all_msgs(), send_control(), send_control_to(), transport_stop(), and ~TransportClient().

◆ reverse_lock_

Reverse_Lock_t OpenDDS::DCPS::TransportClient::reverse_lock_

private

Definition at line 349 of file TransportClient.h.

Referenced by associate(), and initiate_connect_i().

◆ send_transaction_lock_

ACE_Thread_Mutex OpenDDS::DCPS::TransportClient::send_transaction_lock_

private

Definition at line 327 of file TransportClient.h.

Referenced by send(), and send_w_control().

◆ swap_bytes_

bool OpenDDS::DCPS::TransportClient::swap_bytes_

private

Definition at line 340 of file TransportClient.h.

Referenced by enable_transport_using_config().

The documentation for this class was generated from the following files:

Classes

Public Types

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Friends

Detailed Description

Member Typedef Documentation

◆ Guard

◆ PendingAssoc_rch

◆ Reverse_Lock_t

Member Enumeration Documentation

◆ anonymous enum

Constructor & Destructor Documentation

◆ TransportClient()

◆ ~TransportClient()

Member Function Documentation

◆ add_link()

◆ associate()

◆ associated_with()

◆ cdr_encapsulation() [1/2]

◆ cdr_encapsulation() [2/2]

◆ check_transport_qos()

◆ clean_prev_pending()

◆ connection_info()

◆ data_acked()

◆ disassociate()

◆ domain_id()

◆ enable_transport()

◆ enable_transport_using_config()

◆ get_builtin_subscriber_proxy()

◆ get_crypto_handle()

◆ get_guid()

◆ get_ice_endpoint()

◆ get_max_sn()

◆ get_priority_value()

◆ get_receive_listener()

◆ get_send_listener()

◆ initiate_connect_i()

◆ is_leading()

◆ is_reliable()

◆ OPENDDS_MAP_CMP() [1/2]

◆ OPENDDS_MAP_CMP() [2/2]

◆ OPENDDS_MULTIMAP_CMP()

◆ OPENDDS_VECTOR()

◆ pending_association_with()

◆ populate_connection_info()

◆ register_for_reader()

◆ register_for_writer()

◆ remove_all_msgs()

◆ remove_sample()

◆ repo_id()

◆ send()

◆ send_control()

◆ send_control_to()

◆ send_final_acks()

◆ send_i()

◆ send_response()

◆ send_w_control()

◆ stop_associating() [1/2]

◆ stop_associating() [2/2]

◆ swap_bytes()

◆ terminate_send_if_suspended()

◆ transport_assoc_done()

◆ transport_stop()

◆ unregister_for_reader()

◆ unregister_for_writer()

◆ update_locators()

◆ use_datalink()

◆ use_datalink_i()

Friends And Related Function Documentation

◆ ::DDS_TEST

Member Data Documentation

◆ cdr_encapsulation_

◆ config_

◆ conn_info_

◆ data_link_index_

◆ durable_