MINT::counted_ptr< X > Class Template Reference

#include <counted_ptr.h>

Inheritance diagram for MINT::counted_ptr< X >:

Public Types
typedef X	element_type

Public Member Functions
bool	ok () const
void	acquire (const counted_ptr< X > &other) throw ()
template<typename Y >
void	acquire (const counted_ptr< Y > &other) throw ()
void	release ()
	counted_ptr (X *p=0)
	~counted_ptr ()
	counted_ptr (const counted_ptr &r) throw ()
counted_ptr &	operator= (const counted_ptr &r)
template<typename Y >
	counted_ptr (const counted_ptr< Y > &r) throw ()
template<typename Y >
counted_ptr &	operator= (const counted_ptr< Y > &r)
X *	get () const throw ()
X &	operator * () const throw ()
X *	operator-> () const throw ()
bool	unique () const throw ()
	operator const void * () const
void	acquire (counted_ptr_counter *c) throw ()
void	release ()
	counted_ptr (X *p=0)
	~counted_ptr ()
	counted_ptr (const counted_ptr &r) throw ()
counted_ptr &	operator= (const counted_ptr &r)
template<class Y >
	counted_ptr (const counted_ptr< Y > &r) throw ()
template<class Y >
counted_ptr &	operator= (const counted_ptr< Y > &r)
X &	operator * () const throw ()
X *	operator-> () const throw ()
X *	get () const throw ()
bool	unique () const throw ()
	operator void * () const

Public Attributes
X *	ptr
counted_ptr_counter *	itsCounter

Detailed Description

template<typename X>
class MINT::counted_ptr< X >

Definition at line 39 of file counted_ptr.h.

Member Typedef Documentation

element_type

template<typename X>

typedef X MINT::counted_ptr< X >::element_type

Definition at line 67 of file old_counted_ptr.h.

Constructor & Destructor Documentation

counted_ptr() [1/6]

template<typename X>

MINT::counted_ptr< X >::counted_ptr ( X *  p = 0 )

inline

Definition at line 80 of file counted_ptr.h.

   : ptr(p)
    , itsCounter(0){
    if (0 != p){
      itsCounter = new counted_ptr_counter(1);
      ptr = p;
    }
  }

~counted_ptr() [1/2]

template<typename X>

MINT::counted_ptr< X >::~counted_ptr ( )

inline

Definition at line 88 of file counted_ptr.h.

    {release();}

counted_ptr() [2/6]

template<typename X>

MINT::counted_ptr< X >::counted_ptr ( const counted_ptr< X > &  r ) throw ( )

inline

Definition at line 90 of file counted_ptr.h.

    {
      // std::cout << "copy-constructing" << std::endl;
      acquire(r);
    }

counted_ptr() [3/6]

template<typename X>

template<typename Y >

MINT::counted_ptr< X >::counted_ptr ( const counted_ptr< Y > &  r ) throw ( )

inline

Definition at line 107 of file counted_ptr.h.

        {
      // std::cout << "copy-constructing other" << std::endl;
      acquire(r);
    }

counted_ptr() [4/6]

template<typename X>

MINT::counted_ptr< X >::counted_ptr ( X *  p = 0 )

inlineexplicit

Definition at line 69 of file old_counted_ptr.h.

    : itsCounter(0) {if (p) itsCounter = new counted_ptr_counter(p);}

~counted_ptr() [2/2]

template<typename X>

MINT::counted_ptr< X >::~counted_ptr ( )

inline

Definition at line 71 of file old_counted_ptr.h.

    {release();}

counted_ptr() [5/6]

template<typename X>

MINT::counted_ptr< X >::counted_ptr ( const counted_ptr< X > &  r ) throw ( )

inline

Definition at line 73 of file old_counted_ptr.h.

    {acquire(r.itsCounter);}

counted_ptr() [6/6]

template<typename X>

template<class Y >

MINT::counted_ptr< X >::counted_ptr ( const counted_ptr< Y > &  r ) throw ( )

inline

Definition at line 86 of file old_counted_ptr.h.

        {
      // with this trick we check (I hope) if the conversion
      // is legal (jr):
      static_cast<X*>(r.get());
      acquire(r.itsCounter);
    }

Member Function Documentation

acquire() [1/3]

template<typename X>

void MINT::counted_ptr< X >::acquire ( counted_ptr_counter *  c ) throw ( )

inline

Definition at line 49 of file old_counted_ptr.h.

    { // increment the count
        itsCounter = c;
        if (c) ++(c->count);
    }

acquire() [2/3]

template<typename X>

void MINT::counted_ptr< X >::acquire ( const counted_ptr< X > &  other ) throw ( )

inline

Definition at line 50 of file counted_ptr.h.

  { // increment the count
    // std::cout << "acquiring" << std::endl;
    itsCounter = other.itsCounter;
    ptr = other.ptr;
    if (ok()) ++(itsCounter->count);
  }

acquire() [3/3]

template<typename X>

template<typename Y >

void MINT::counted_ptr< X >::acquire ( const counted_ptr< Y > &  other ) throw ( )

inline

Definition at line 59 of file counted_ptr.h.

  { // increment the count
    // std::cout << "acquiring different type" << std::endl;
    itsCounter = other.itsCounter;
    ptr = (X*) (other.ptr);
    if (ok()) ++(itsCounter->count);
  }

get() [1/2]

template<typename X>

X* MINT::counted_ptr< X >::get ( ) const throw ( )

inline

Definition at line 108 of file old_counted_ptr.h.

{return ((itsCounter) ? static_cast<X*>(itsCounter->ptr) : 0);}

get() [2/2]

template<typename X>

X* MINT::counted_ptr< X >::get ( ) const throw ( )

inline

Definition at line 123 of file counted_ptr.h.

{return (this->ok() ? ptr : 0);}

ok()

template<typename X>

bool MINT::counted_ptr< X >::ok ( ) const

inline

Definition at line 46 of file counted_ptr.h.

                 {
    return (0 != itsCounter) && (0 != ptr);
  }

operator *() [1/2]

template<typename X>

X& MINT::counted_ptr< X >::operator * ( ) const throw ( )

inline

Definition at line 106 of file old_counted_ptr.h.

{return *(static_cast<X*>(itsCounter->ptr));}

operator *() [2/2]

template<typename X>

X& MINT::counted_ptr< X >::operator * ( ) const throw ( )

inline

Definition at line 124 of file counted_ptr.h.

{return *(get());}

operator const void *()

template<typename X>

MINT::counted_ptr< X >::operator const void * ( ) const

inline

Definition at line 130 of file counted_ptr.h.

                                { // jr
      return (const void*) get();
    }

operator void *()

template<typename X>

MINT::counted_ptr< X >::operator void * ( ) const

inline

Definition at line 113 of file old_counted_ptr.h.

                          { // jr
      return (void*) get();
    }

operator->() [1/2]

template<typename X>

X* MINT::counted_ptr< X >::operator-> ( ) const throw ( )

inline

Definition at line 107 of file old_counted_ptr.h.

{return static_cast<X*>(itsCounter->ptr);}

operator->() [2/2]

template<typename X>

X* MINT::counted_ptr< X >::operator-> ( ) const throw ( )

inline

Definition at line 125 of file counted_ptr.h.

{return get();}

operator=() [1/4]

template<typename X>

counted_ptr& MINT::counted_ptr< X >::operator= ( const counted_ptr< X > &  r )

inline

Definition at line 75 of file old_counted_ptr.h.

    {
      if (this != &r) {
    release();
    acquire(r.itsCounter);
      }
      return *this;
    }

operator=() [2/4]

template<typename X>

template<class Y >

counted_ptr& MINT::counted_ptr< X >::operator= ( const counted_ptr< Y > &  r )

inline

Definition at line 93 of file old_counted_ptr.h.

    {
        if (this != &r) {
      // with this trick we check (I hope) if the conversion
      // is legal (jr):
      static_cast<X*>(r.get());
      release();
      acquire(r.itsCounter);
        }
        return *this;
    }

operator=() [3/4]

template<typename X>

counted_ptr& MINT::counted_ptr< X >::operator= ( const counted_ptr< X > &  r )

inline

Definition at line 95 of file counted_ptr.h.

    {
      // std::cout << "copy- = " << std::endl;
      if (this != &r) {
    release();
    acquire(r);
      }
      return *this;
    }

operator=() [4/4]

template<typename X>

template<typename Y >

counted_ptr& MINT::counted_ptr< X >::operator= ( const counted_ptr< Y > &  r )

inline

Definition at line 112 of file counted_ptr.h.

      {
    if ((const void*)this != (const void*) (&r)) {
      release();
      // std::cout << "copy = other" << std::endl;
      acquire(r);
    }
        return *this;
      }

release() [1/2]

template<typename X>

void MINT::counted_ptr< X >::release ( )

inline

Definition at line 55 of file old_counted_ptr.h.

    { // decrement the count, delete if it is 0
        if (itsCounter) {
            if (--itsCounter->count == 0) {
                delete (X*)(itsCounter->ptr);
                delete itsCounter;
            }
            itsCounter = 0;
        }
    }

release() [2/2]

template<typename X>

void MINT::counted_ptr< X >::release ( )

inline

Definition at line 67 of file counted_ptr.h.

  { // decrement the count, delete if it is 0
    // std::cout << "releasing" << std::endl;
    if (ok()) {
      if (--(itsCounter->count) == 0) {
    delete ptr;
    delete itsCounter;
      }
      ptr=0;
      itsCounter = 0;
    }
  }

unique() [1/2]

template<typename X>

bool MINT::counted_ptr< X >::unique ( ) const throw ( )

inline

Definition at line 109 of file old_counted_ptr.h.

        {return (itsCounter ? itsCounter->count == 1 : true);}

unique() [2/2]

template<typename X>

bool MINT::counted_ptr< X >::unique ( ) const throw ( )

inline

Definition at line 126 of file counted_ptr.h.

        {return (itsCounter ? itsCounter->count == 1 : true);}

Member Data Documentation

itsCounter

template<typename X>

counted_ptr_counter * MINT::counted_ptr< X >::itsCounter

Definition at line 44 of file counted_ptr.h.

ptr

template<typename X>

X* MINT::counted_ptr< X >::ptr

Definition at line 43 of file counted_ptr.h.

---

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

• Mint/counted_ptr.h
• Mint/old_counted_ptr.h