ReferenceCountedObject< T > Class Template Reference

#include <reference_counted_object.h>

Inheritance diagram for ReferenceCountedObject< T >:

[legend]

List of all members.

Public Member Functions
virtual	~ReferenceCountedObject ()
Static Public Member Functions
static std::string	get_info ()
static void	print_info ()
static unsigned int	n_objects ()
Protected Types
typedef std::map< std::string, std::pair< unsigned int, unsigned int > >	Counts
Protected Member Functions
	ReferenceCountedObject ()
void	increment_constructor_count (const std::string &name)
void	increment_destructor_count (const std::string &name)
Static Protected Attributes
static Counts	_counts
static Threads::atomic < unsigned int >	_n_objects
static Threads::spin_mutex	_mutex

---

Detailed Description

template<typename T>
class ReferenceCountedObject< T >

This class implements reference counting. Any class that is properly derived from this class will get reference counted, provided that the library is configured with --enable-reference-counting and you are compiling with DEBUG defined. For example, the following is sufficient to define the class Foo as a reference counted class:

 class Foo : public ReferenceCountedObject<Foo>
 {
  public:

    Foo  () {}

    ~Foo () {}

    void bar ();
 
  private:
 };

If the library is configured with --disable-reference-counting or DEBUG is not defined then this class does nothing. All members are inlined and empty, so they should effectively disappear.

Author:

Benjamin S. Kirk, 2002-2007

Definition at line 68 of file reference_counted_object.h.

---

Member Typedef Documentation

typedef std::map<std::string, std::pair<unsigned int, unsigned int> > ReferenceCounter::Counts [protected, inherited]

Data structure to log the information. The log is identified by the class name.

Definition at line 105 of file reference_counter.h.

---

Constructor & Destructor Documentation

template<typename T >

ReferenceCountedObject< T >::ReferenceCountedObject

(

)

[inline, protected]

Constructor. Protected so that you cannont instantiate a ReferenceCountedObject, only derive from it.

Definition at line 77 of file reference_counted_object.h.

  {
#if defined(LIBMESH_ENABLE_REFERENCE_COUNTING) && defined(DEBUG)
    
    increment_constructor_count(typeid(T).name());

#endif
  }

template<typename T >

virtual ReferenceCountedObject< T >::~ReferenceCountedObject

(

)

[inline, virtual]

Destructor.

Definition at line 91 of file reference_counted_object.h.

  {
#if defined(LIBMESH_ENABLE_REFERENCE_COUNTING) && defined(DEBUG)
    
    increment_destructor_count(typeid(T).name());

#endif
  }

---

Member Function Documentation

std::string ReferenceCounter::get_info

(

)

[static, inherited]

Gets a string containing the reference information.

Definition at line 45 of file reference_counter.C.

References ReferenceCounter::_counts, and QuadratureRules::name().

Referenced by ReferenceCounter::print_info().

{
#if defined(LIBMESH_ENABLE_REFERENCE_COUNTING) && defined(DEBUG)

  std::ostringstream out;
  
  out << '\n'
      << " ---------------------------------------------------------------------------- \n"
      << "| Reference count information                                                |\n"
      << " ---------------------------------------------------------------------------- \n";
  
  for (Counts::iterator it = _counts.begin();
       it != _counts.end(); ++it)
    {
      const std::string name(it->first);
      const unsigned int creations    = it->second.first;
      const unsigned int destructions = it->second.second;

      out << "| " << name << " reference count information:\n"
          << "|  Creations:    " << creations    << '\n'
          << "|  Destructions: " << destructions << '\n';
    }
  
  out << " ---------------------------------------------------------------------------- \n";

  return out.str();

#else

  return "";
  
#endif
}

void ReferenceCounter::increment_constructor_count

(

const std::string &

name

)

[inline, protected, inherited]

Increments the construction counter. Should be called in the constructor of any derived class that will be reference counted.

Definition at line 149 of file reference_counter.h.

References ReferenceCounter::_counts, and Threads::spin_mtx.

Referenced by ReferenceCountedObject< SparseMatrix< T > >::ReferenceCountedObject().

{
  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
  std::pair<unsigned int, unsigned int>& p = _counts[name];

  p.first++;
}

void ReferenceCounter::increment_destructor_count

(

const std::string &

name

)

[inline, protected, inherited]

Increments the destruction counter. Should be called in the destructor of any derived class that will be reference counted.

Definition at line 167 of file reference_counter.h.

References ReferenceCounter::_counts, and Threads::spin_mtx.

Referenced by ReferenceCountedObject< SparseMatrix< T > >::~ReferenceCountedObject().

{
  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
  std::pair<unsigned int, unsigned int>& p = _counts[name];

  p.second++;
}

static unsigned int ReferenceCounter::n_objects

(

)

[inline, static, inherited]

Prints the number of outstanding (created, but not yet destroyed) objects.

Definition at line 76 of file reference_counter.h.

References ReferenceCounter::_n_objects.

  { return _n_objects; }

void ReferenceCounter::print_info

(

)

[static, inherited]

Prints the reference information to std::cout.

Definition at line 83 of file reference_counter.C.

References ReferenceCounter::get_info().

{
#if defined(LIBMESH_ENABLE_REFERENCE_COUNTING) && defined(DEBUG)
  
  std::cout << ReferenceCounter::get_info();
  
#endif
}

---

Member Data Documentation

ReferenceCounter::Counts ReferenceCounter::_counts [static, protected, inherited]

Actually holds the data.

Definition at line 110 of file reference_counter.h.

Referenced by ReferenceCounter::get_info(), ReferenceCounter::increment_constructor_count(), and ReferenceCounter::increment_destructor_count().

Threads::spin_mutex ReferenceCounter::_mutex [static, protected, inherited]

Mutual exclusion object to enable thread-safe reference counting.

Definition at line 123 of file reference_counter.h.

Threads::atomic< unsigned int > ReferenceCounter::_n_objects [static, protected, inherited]

The number of objects. Print the reference count information when the number returns to 0.

Definition at line 118 of file reference_counter.h.

Referenced by ReferenceCounter::n_objects(), ReferenceCounter::ReferenceCounter(), and ReferenceCounter::~ReferenceCounter().

---

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

• reference_counted_object.h