referenceCount.h

Go to the documentation of this file.

#ifndef _DLR_COMMON_REFERENCECOUNT_H_
#define _DLR_COMMON_REFERENCECOUNT_H_

#include <cstddef>

namespace dlr {

  namespace common {
    
    class ReferenceCount
    {
    public:
      ReferenceCount(size_t count=1)
        : m_countPtr(0) {
        if(count != 0) {
          m_countPtr = new size_t;
          *m_countPtr = count;
        }
      }

    
      ReferenceCount(const ReferenceCount& other)
        : m_countPtr(other.m_countPtr) {
        if(m_countPtr != 0) {++(*m_countPtr);}
      }

    
      ~ReferenceCount() {this->deleteIfNecessary();}

    
      ReferenceCount&
      operator++() {
        if(m_countPtr != 0) {++(*m_countPtr);}
        return *this;
      }

    
      ReferenceCount
      operator++(int) {return ++(*this);}

    
      ReferenceCount&
      operator--() {
        if(m_countPtr != 0) {
          if((*m_countPtr) != 0) {--(*m_countPtr);}
        }
        return *this;
      }

    
      ReferenceCount
      operator--(int) {return --(*this);}


      ReferenceCount&
      operator+=(size_t offset) {
        if(m_countPtr != 0) {(*m_countPtr) += offset;}
        return *this;
      }

    
      ReferenceCount&
      operator-=(size_t offset) {
        if(m_countPtr != 0) {
          if((*m_countPtr) > offset) {(*m_countPtr) -= offset;}
          else {(*m_countPtr) = 0;}
        }
        return *this;
      }

    
      ReferenceCount&
      operator=(const ReferenceCount& source) {
        // Check for self-assignment.
        if (this != &source) {
          this->deleteIfNecessary();
          m_countPtr = source.m_countPtr;
          if(m_countPtr != 0) {++(*m_countPtr);}
        }
        return *this;
      }

    
      size_t
      count() const {return *m_countPtr;}

    
      bool
      isShared() const {
        if(m_countPtr == 0) {return false;}
        return ((*m_countPtr) > 1);
      }

    
      void
      reset(size_t count=1) {
        this->deleteIfNecessary();
        if(count != 0) {
          m_countPtr = new size_t;
          *m_countPtr = count;
        }
      }

      
      bool
      shared() const {
        return this->isShared();
      }

    
    private:

      void deleteIfNecessary() {
        if(m_countPtr != 0) {
          switch(*m_countPtr) {
          case 0:
          case 1:
            delete m_countPtr;
            m_countPtr = 0;
            break;
          default:
            --(*m_countPtr);
          }
        }
      }
    
      size_t* m_countPtr;
    };

  } // namespace common
  
} // namespace dlr


/* ======= Declarations to maintain compatibility with legacy code. ======= */

namespace dlr {

  using common::ReferenceCount;
  
} // namespace dlr

#endif // #ifndef _DLR_COMMON_REFERENCECOUNT_H_