MINT::const_counted_ptr< X > Class Template Reference

#include <counted_ptr.h>

Inheritance diagram for MINT::const_counted_ptr< X >:

Public Member Functions
bool	ok () const
void	acquire (const counted_ptr< X > &c) throw ()
template<typename Y >
void	acquire (const counted_ptr< Y > &other) throw ()
void	release ()
	const_counted_ptr (X *p=0)
	~const_counted_ptr ()
	const_counted_ptr (const const_counted_ptr &other) throw ()
	const_counted_ptr (const counted_ptr< X > &other) throw ()
const_counted_ptr &	operator= (const const_counted_ptr &r)
const_counted_ptr &	operator= (const counted_ptr< X > &r)
template<typename Y >
	const_counted_ptr (const const_counted_ptr< Y > &r) throw ()
template<typename Y >
	const_counted_ptr (const counted_ptr< Y > &r) throw ()
template<typename Y >
const_counted_ptr &	operator= (const const_counted_ptr< Y > &r)
template<class Y >
const_counted_ptr &	operator= (const counted_ptr< Y > &r)
const X *	get () const throw ()
const X &	operator * () const throw ()
const X *	operator-> () const throw ()
void	acquire (counted_ptr_counter *c) throw ()
void	release ()
	const_counted_ptr (X *p=0)
	~const_counted_ptr ()
	const_counted_ptr (const const_counted_ptr &other) throw ()
	const_counted_ptr (const counted_ptr< X > &other) throw ()
const_counted_ptr &	operator= (const const_counted_ptr &r)
const_counted_ptr &	operator= (const counted_ptr< X > &r)
template<class Y >
	const_counted_ptr (const const_counted_ptr< Y > &r) throw ()
template<class Y >
	const_counted_ptr (const counted_ptr< Y > &r) throw ()
template<class Y >
const_counted_ptr &	operator= (const const_counted_ptr< Y > &r)
template<class Y >
const_counted_ptr &	operator= (const counted_ptr< Y > &r)
const X &	operator * () const throw ()
const X *	operator-> () const throw ()
const X *	get () const throw ()
Public Member Functions inherited from MINT::counted_ptr< X >
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

Additional Inherited Members
Public Types inherited from MINT::counted_ptr< X >
typedef X	element_type
Public Attributes inherited from MINT::counted_ptr< X >
X *	ptr
counted_ptr_counter *	itsCounter

Detailed Description

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

Definition at line 150 of file counted_ptr.h.

Constructor & Destructor Documentation

const_counted_ptr() [1/10]

template<typename X>

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

inlineexplicit

Definition at line 165 of file counted_ptr.h.

    : counted_ptr<X>(p){};

~const_counted_ptr() [1/2]

template<typename X>

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

inline

Definition at line 167 of file counted_ptr.h.

    {release();}

const_counted_ptr() [2/10]

template<typename X>

MINT::const_counted_ptr< X >::const_counted_ptr ( const const_counted_ptr< X > &  other ) throw ( )

inline

Definition at line 169 of file counted_ptr.h.

    :counted_ptr<X>(other)
    {}

const_counted_ptr() [3/10]

template<typename X>

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

inline

Definition at line 172 of file counted_ptr.h.

    :counted_ptr<X>(other)
    {}

const_counted_ptr() [4/10]

template<typename X>

template<typename Y >

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

inline

Definition at line 192 of file counted_ptr.h.

    {
      acquire(r);
    }

const_counted_ptr() [5/10]

template<typename X>

template<typename Y >

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

inline

Definition at line 196 of file counted_ptr.h.

    {
      acquire(r);
    }

const_counted_ptr() [6/10]

template<typename X>

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

inlineexplicit

Definition at line 140 of file old_counted_ptr.h.

    : counted_ptr<X>(p){};

~const_counted_ptr() [2/2]

template<typename X>

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

inline

Definition at line 142 of file old_counted_ptr.h.

    {release();}

const_counted_ptr() [7/10]

template<typename X>

MINT::const_counted_ptr< X >::const_counted_ptr ( const const_counted_ptr< X > &  other ) throw ( )

inline

Definition at line 144 of file old_counted_ptr.h.

    :counted_ptr<X>(other)
    {}

const_counted_ptr() [8/10]

template<typename X>

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

inline

Definition at line 147 of file old_counted_ptr.h.

    :counted_ptr<X>(other)
    {}

const_counted_ptr() [9/10]

template<typename X>

template<class Y >

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

inline

Definition at line 168 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);
    }

const_counted_ptr() [10/10]

template<typename X>

template<class Y >

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

inline

Definition at line 175 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::const_counted_ptr< X >::acquire ( counted_ptr_counter *  c ) throw ( )

inline

Definition at line 135 of file old_counted_ptr.h.

                                              {
    counted_ptr<X>::acquire(c);}

acquire() [2/3]

template<typename X>

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

inline

Definition at line 155 of file counted_ptr.h.

                                               {
    counted_ptr<X>::acquire(c);}

acquire() [3/3]

template<typename X>

template<typename Y >

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

inline

Definition at line 159 of file counted_ptr.h.

                                                     {
    counted_ptr<X>::acquire(other);}

get() [1/2]

template<typename X>

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

inline

Definition at line 207 of file old_counted_ptr.h.

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

get() [2/2]

template<typename X>

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

inline

Definition at line 217 of file counted_ptr.h.

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

ok()

template<typename X>

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

inline

Definition at line 152 of file counted_ptr.h.

                 {
    return counted_ptr<X>::ok();
  }

operator *() [1/2]

template<typename X>

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

inline

Definition at line 205 of file old_counted_ptr.h.

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

operator *() [2/2]

template<typename X>

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

inline

Definition at line 219 of file counted_ptr.h.

{return *(static_cast<const X*>(get()));}

operator->() [1/2]

template<typename X>

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

inline

Definition at line 206 of file old_counted_ptr.h.

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

operator->() [2/2]

template<typename X>

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

inline

Definition at line 220 of file counted_ptr.h.

{return static_cast<const X*>(get());}

operator=() [1/8]

template<typename X>

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

inline

Definition at line 150 of file old_counted_ptr.h.

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

operator=() [2/8]

template<typename X>

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

inline

Definition at line 158 of file old_counted_ptr.h.

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

operator=() [3/8]

template<typename X>

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

inline

Definition at line 175 of file counted_ptr.h.

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

operator=() [4/8]

template<typename X>

template<class Y >

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

inline

Definition at line 182 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=() [5/8]

template<typename X>

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

inline

Definition at line 183 of file counted_ptr.h.

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

operator=() [6/8]

template<typename X>

template<class Y >

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

inline

Definition at line 193 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=() [7/8]

template<typename X>

template<typename Y >

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

inline

Definition at line 200 of file counted_ptr.h.

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

operator=() [8/8]

template<typename X>

template<class Y >

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

inline

Definition at line 208 of file counted_ptr.h.

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

release() [1/2]

template<typename X>

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

inline

Definition at line 137 of file old_counted_ptr.h.

                {
    counted_ptr<X>::release();}

release() [2/2]

template<typename X>

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

inline

Definition at line 162 of file counted_ptr.h.

                {
    counted_ptr<X>::release();}

---

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

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