www.pudn.com > ACE-5.3 > Based_Pointer_Repository.cpp, change:2002-12-30,size:4553b

// Based_Pointer_Repository.cpp,v 4.12 2002/12/31 02:31:46 shuston Exp 
 
#include "ace/Map_Manager.h" 
#include "ace/Based_Pointer_Repository.h" 
 
/** 
 * @class ACE_Based_Pointer_Repository_Rep 
 * 
 * @brief Implementation for the <ACE_Based_Pointer_Repository>. 
 * 
 * Every memory pool in ACE binds it's mapping base address and 
 * the mapped size to this repository every time it maps/remaps a 
 * new chunk of memory successfully. 
 */ 
class ACE_Based_Pointer_Repository_Rep 
{ 
public: 
  // Useful typedefs. 
  typedef ACE_Map_Manager <void *, size_t, ACE_Null_Mutex> MAP_MANAGER; 
  typedef ACE_Map_Iterator  void *, size_t, ACE_Null_Mutex> MAP_ITERATOR; 
  typedef ACE_Map_Entry <void *, size_t> MAP_ENTRY; 
 
  /// Keeps track of the mapping between addresses and their associated 
  /// values. 
  MAP_MANAGER addr_map_; 
 
  /// Synchronize concurrent access to the map. 
  ACE_SYNCH_MUTEX lock_; 
}; 
 
ACE_Based_Pointer_Repository::ACE_Based_Pointer_Repository (void) 
{ 
  ACE_TRACE ("ACE_Based_Pointer_Repository::ACE_Based_Pointer_Repository"); 
  ACE_NEW (this->rep_, 
           ACE_Based_Pointer_Repository_Rep); 
} 
 
ACE_Based_Pointer_Repository::~ACE_Based_Pointer_Repository (void) 
{ 
  ACE_TRACE ("ACE_Based_Pointer_Repository::~ACE_Based_Pointer_Repository"); 
  delete this->rep_; 
} 
 
// Search for appropriate base address in repository 
 
int 
ACE_Based_Pointer_Repository::find (void *addr, 
                                    void *&base_addr) 
{ 
  ACE_TRACE ("ACE_Based_Pointer_Repository::find"); 
  ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, mon, this->rep_->lock_, -1); 
  ACE_Based_Pointer_Repository_Rep::MAP_ENTRY *ce = 0; 
 
  for (ACE_Based_Pointer_Repository_Rep::MAP_ITERATOR iter (this->rep_->addr_map_); 
       iter.next (ce) != 0; 
       iter.advance ()) 
    // Check to see if <addr> is within any of the regions. 
    if (addr >= ce->ext_id_ 
        && addr  ((char *) ce->ext_id_ + ce->int_id_)) 
      { 
        // Assign the base address. 
        base_addr = ce->ext_id_; 
        return 1; 
      } 
 
  // Assume base address 0 (e.g., if new'ed). 
  base_addr = 0; 
  return 0; 
} 
 
// Bind a new entry to the repository or update the size of an 
// existing entry. 
 
int 
ACE_Based_Pointer_Repository::bind (void *addr, 
                                    size_t size) 
{ 
  ACE_TRACE ("ACE_Based_Pointer_Repository::bind"); 
  ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, mon, this->rep_->lock_, -1); 
 
  return this->rep_->addr_map_.rebind (addr, size); 
} 
 
// Unbind a base from the repository. 
 
int 
ACE_Based_Pointer_Repository::unbind (void *addr) 
{ 
  ACE_TRACE ("ACE_Based_Pointer_Repository::unbind"); 
  ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, mon, this->rep_->lock_, -1); 
  ACE_Based_Pointer_Repository_Rep::MAP_ENTRY *ce = 0; 
 
  // Search for service handlers that requested notification. 
 
  for (ACE_Based_Pointer_Repository_Rep::MAP_ITERATOR iter (this->rep_->addr_map_); 
       iter.next (ce) != 0; 
       iter.advance ()) 
    { 
      // Check to see if <addr> is within any of the regions and if 
      // so, unbind the key from the map. 
      if (addr >= ce->ext_id_ 
          && addr  ((char *) ce->ext_id_ + ce->int_id_)) 
        // Unbind base address. 
        return this->rep_->addr_map_.unbind (ce->ext_id_); 
    } 
 
  return 0; 
} 
 
#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) 
template class ACE_Singleton <ACE_Based_Pointer_Repository, ACE_SYNCH_RW_MUTEX>; 
template class ACE_Map_Entry<void *, size_t>; 
template class ACE_Map_Manager<void *, size_t, ACE_Null_Mutex>; 
template class ACE_Map_Iterator<void *, size_t, ACE_Null_Mutex>; 
template class ACE_Map_Reverse_Iterator<void *, size_t, ACE_Null_Mutex>; 
template class ACE_Map_Iterator_Base<void *, size_t, ACE_Null_Mutex>; 
#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) 
#pragma instantiate ACE_Singleton <ACE_Based_Pointer_Repository, ACE_SYNCH_RW_MUTEX> 
#pragma instantiate ACE_Map_Entry<void *, size_t> 
#pragma instantiate ACE_Map_Manager<void *, size_t, ACE_Null_Mutex> 
#pragma instantiate ACE_Map_Iterator<void *, size_t, ACE_Null_Mutex> 
#pragma instantiate ACE_Map_Reverse_Iterator<void *, size_t, ACE_Null_Mutex> 
#pragma instantiate ACE_Map_Iterator_Base<void *, size_t, ACE_Null_Mutex> 
#elif defined (__GNUC__) && (defined (_AIX) || defined (__hpux)) 
template ACE_Singleton<ACE_Based_Pointer_Repository, ACE_SYNCH_RW_MUTEX> * 
  ACE_Singleton<ACE_Based_Pointer_Repository, ACE_SYNCH_RW_MUTEX>::singleton_; 
#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */