#include <AddressCache.h>

Collaboration diagram for OpenDDS::DCPS::AddressCache< Key >:

Classes
struct	ScopedAccess

Public Member Functions
typedef	OPENDDS_MAP_T (Key, RcHandle< AddressCacheEntry >) MapType

typedef	OPENDDS_VECTOR (Key) KeyVec

typedef	OPENDDS_MAP_T (GUID_t, KeyVec) IdMapType

	AddressCache ()

virtual	~AddressCache ()

bool	load (const Key &key, AddrSet &addrs) const

void	store (const Key &key, const AddrSet &addrs, const MonotonicTimePoint &expires=MonotonicTimePoint::max_value)

bool	remove (const Key &key)

void	remove_id (const GUID_t &val)

Private Attributes
ACE_Thread_Mutex	mutex_

MapType	map_

IdMapType	id_map_

Detailed Description

template<typename Key>
class OpenDDS::DCPS::AddressCache< Key >

Definition at line 84 of file AddressCache.h.

Constructor & Destructor Documentation

◆ AddressCache()

template<typename Key>

OpenDDS::DCPS::AddressCache< Key >::AddressCache ( )

inline

Definition at line 97 of file AddressCache.h.

97 {}

◆ ~AddressCache()

template<typename Key>

virtual OpenDDS::DCPS::AddressCache< Key >::~AddressCache ( )

inlinevirtual

Definition at line 98 of file AddressCache.h.

98 {}

Member Function Documentation

◆ load()

template<typename Key>

bool OpenDDS::DCPS::AddressCache< Key >::load	(	const Key &	key,
		AddrSet &	addrs
	)		const

inline

Definition at line 182 of file AddressCache.h.

   {
     ACE_Guard<ACE_Thread_Mutex> guard(mutex_);
     const typename MapType::const_iterator pos = map_.find(key);
     if (pos != map_.end()) {
       if (MonotonicTimePoint::now() < pos->second->expires_) {
         const AddrSet& as = pos->second->addrs_;
         for (AddrSet::const_iterator it = as.begin(), limit = as.end(); it != limit; ++it) {
           addrs.insert(*it);
         }
         return true;
       }
     }
     return false;
   }

◆ OPENDDS_MAP_T() [1/2]

template<typename Key>

typedef OpenDDS::DCPS::AddressCache< Key >::OPENDDS_MAP_T	(	Key	,
		RcHandle< AddressCacheEntry >
	)

◆ OPENDDS_MAP_T() [2/2]

template<typename Key>

typedef OpenDDS::DCPS::AddressCache< Key >::OPENDDS_MAP_T	(	GUID_t	,
		KeyVec
	)

◆ OPENDDS_VECTOR()

template<typename Key>

typedef OpenDDS::DCPS::AddressCache< Key >::OPENDDS_VECTOR ( Key )

◆ remove()

template<typename Key>

bool OpenDDS::DCPS::AddressCache< Key >::remove ( const Key & key )

inline

Definition at line 215 of file AddressCache.h.

   {
     ACE_Guard<ACE_Thread_Mutex> guard(mutex_);
     return map_.erase(key) != 0;
   }

◆ remove_id()

template<typename Key>

void OpenDDS::DCPS::AddressCache< Key >::remove_id ( const GUID_t & val )

inline

Definition at line 221 of file AddressCache.h.

Referenced by OpenDDS::DCPS::RtpsUdpDataLink::remove_locator_and_bundling_cache(), and OpenDDS::DCPS::RtpsUdpDataLink::RtpsWriter::update_remote_guids_cache_i().

   {
     ACE_Guard<ACE_Thread_Mutex> guard(mutex_);
     const typename IdMapType::iterator pos = id_map_.find(val);
     if (pos != id_map_.end()) {
       for (typename KeyVec::iterator it = pos->second.begin(), limit = pos->second.end(); it != limit; ++it) {
         map_.erase(*it);
       }
       id_map_.erase(pos);
     }
   }

◆ store()

template<typename Key>

void OpenDDS::DCPS::AddressCache< Key >::store	(	const Key &	key,
		const AddrSet &	addrs,
		const MonotonicTimePoint &	expires = `MonotonicTimePoint::max_value`
	)

inline

Definition at line 198 of file AddressCache.h.

   {
     ACE_Guard<ACE_Thread_Mutex> guard(mutex_);
     RcHandle<AddressCacheEntry>& rch = map_[key];
     if (rch) {
       rch->addrs_ = addrs;
       rch->expires_ = expires;
     } else {
       rch = make_rch<AddressCacheEntry>(addrs, expires);
       GuidSet set;
       key.get_contained_guids(set);
       for (GuidSet::const_iterator it = set.begin(), limit = set.end(); it != limit; ++it) {
         id_map_[*it].push_back(key);
       }
     }
   }