Pointers.old.H

Go to the documentation of this file.

/*
** (c) 1996-2000 The Regents of the University of California (through
** E.O. Lawrence Berkeley National Laboratory), subject to approval by
** the U.S. Department of Energy.  Your use of this software is under
** license -- the license agreement is attached and included in the
** directory as license.txt or you may contact Berkeley Lab's Technology
** Transfer Department at TTD@lbl.gov.  NOTICE OF U.S. GOVERNMENT RIGHTS.
** The Software was developed under funding from the U.S. Government
** which consequently retains certain rights as follows: the
** U.S. Government has been granted for itself and others acting on its
** behalf a paid-up, nonexclusive, irrevocable, worldwide license in the
** Software to reproduce, prepare derivative works, and perform publicly
** and display publicly.  Beginning five (5) years after the date
** permission to assert copyright is obtained from the U.S. Department of
** Energy, and subject to any subsequent five (5) year renewals, the
** U.S. Government is granted for itself and others acting on its behalf
** a paid-up, nonexclusive, irrevocable, worldwide license in the
** Software to reproduce, prepare derivative works, distribute copies to
** the public, perform publicly and display publicly, and to permit
** others to do so.
*/

#ifndef BL_POINTERS_H
#define BL_POINTERS_H
//
// $Id: Pointers.H,v 1.16 2001/07/31 22:43:19 lijewski Exp $
//
#include <BLassert.H>
#include <BoxLib.H>
#include <UseCount.H>
//
// :

template <class T>
class CpPtr
{
public:
    //
    //
    CpPtr ();
    //
    //
    explicit CpPtr (T* rhs);
    //
    //
    ~CpPtr ();

    CpPtr (const CpPtr<T>& rhs);

    CpPtr<T>& operator= (T* rhs);

    CpPtr<T>& operator= (const CpPtr<T>& rhs);

    T& operator* () const;
    //
    //
    bool isNull () const;
    //
    //
    T* release ();
    //
    //
    bool operator== (const CpPtr<T>& rhs) const;
    //
    //
    bool operator!= (const CpPtr<T>& rhs) const;

protected:

    T* ptr;
};

//
// :

template<class T>
class CpClassPtr
    :
    public CpPtr<T>
{
public:
    //
    //
    CpClassPtr ();
    //
    //
    explicit CpClassPtr (T* rhs);

    CpClassPtr (const CpClassPtr<T>& rhs);

    CpClassPtr<T>& operator= (T* rhs);

    CpClassPtr<T>& operator= (const CpClassPtr<T>& rhs);
    //
    //
    T* operator-> () const;
};

//
// :

template<class T>
class LnPtr
{
public:
    //
    //
    LnPtr ();
    //
    //
    explicit LnPtr (T* rhs);

    LnPtr<T>& operator= (const LnPtr<T>& rhs);

    LnPtr<T>& operator= (T* rhs);

    ~LnPtr ();
    //
    //
    bool unique () const;
    //
    //
    int linkCount () const;

    T& operator* () const;
    //
    //
    bool isNull () const;
    //
    //
    bool operator== (const LnPtr<T>& rhs) const;
    //
    //
     bool operator!= (const LnPtr<T>& rhs) const;

protected:
    T*       ptr;

private:
    UseCount ucnt;
};

//
// :

template<class T>
class LnClassPtr
    :
    public LnPtr<T>
{
public:
    //
    //
    LnClassPtr ();
    //
    //
    explicit LnClassPtr (T* rhs);

    LnClassPtr<T>& operator= (const LnClassPtr<T>& rhs);

    LnClassPtr<T>& operator= (T* rhs);
    //
    //
    T* operator->() const;
};

template <class T>
inline
CpPtr<T>::CpPtr ()
    :
    ptr(0)
{}

template <class T>
inline
CpPtr<T>::CpPtr (T* rhs)
    :
    ptr(rhs)
{}

template <class T>
CpPtr<T>::~CpPtr()
{
    delete ptr;
}

template <class T>
inline
bool
CpPtr<T>::isNull () const
{
    return ptr == 0;
}

template <class T>
CpPtr<T>::CpPtr (const CpPtr<T>& rhs)
{
    ptr = rhs.isNull() ?  0 : new T(*rhs.ptr);
}

template <class T>
CpPtr<T>&
CpPtr<T>::operator= (const CpPtr<T>& rhs)
{
    if (!(ptr == rhs.ptr))
    {
        delete ptr;
        ptr = rhs.isNull() ? 0 : new T(*rhs.ptr);
    }
    return *this;
}

template <class T>
CpPtr<T>&
CpPtr<T>::operator= (T* rhs)
{
    delete ptr;
    ptr = rhs;
    return *this;
}

template <class T>
inline
T&
CpPtr<T>::operator* () const
{
    BL_ASSERT(ptr != 0);
    return *ptr;
}

template <class T>
T*
CpPtr<T>::release ()
{
    T* old = ptr;
    ptr = 0;
    return old;
}

template <class T>
inline
bool
CpPtr<T>::operator== (const CpPtr<T>& rhs) const
{
    return ptr == rhs.ptr;
}

template <class T>
inline
bool
CpPtr<T>::operator!= (const CpPtr<T>& rhs) const
{
    return ptr != rhs.ptr;
}

template <class T>
inline
CpClassPtr<T>::CpClassPtr ()
    :
    CpPtr<T>()
{}

template <class T>
inline
CpClassPtr<T>::CpClassPtr (T* rhs)
    :
    CpPtr<T>(rhs)
{}

template <class T>
CpClassPtr<T>::CpClassPtr (const CpClassPtr<T>& rhs)
    :
    CpPtr<T>(rhs)
{}

template <class T>
inline
CpClassPtr<T>&
CpClassPtr<T>::operator= (T* rhs)
{
    CpPtr<T>::operator= (rhs);
    return *this;
}

template <class T>
inline
CpClassPtr<T>&
CpClassPtr<T>::operator= (const CpClassPtr<T>& rhs)
{
    CpPtr<T>::operator= (rhs);
    return *this;
}

template <class T>
inline
T*
CpClassPtr<T>::operator-> () const
{
    return ptr;
}

template <class T>
LnPtr<T>::LnPtr ()
    :
    ptr(0)
{}

template <class T>
LnPtr<T>::LnPtr(T* rhs)
    :
    ptr(rhs)
{}

template <class T>
LnPtr<T>&
LnPtr<T>::operator= (T* rhs)
{
    if (unique())
        delete ptr;
    ptr = rhs;
    ucnt = UseCount();
    return *this;
}

template <class T>
inline
bool
LnPtr<T>::unique () const
{ 
    return ucnt.unique();
}

template <class T>
LnPtr<T>::~LnPtr ()
{ 
    if (ucnt.unique())
        delete ptr;
}

template <class T>
LnPtr<T>&
LnPtr<T>::operator= (const LnPtr<T>& rhs)
{
    if (ptr != rhs.ptr)
    {
        if (unique())
            delete ptr;
        ptr = rhs.ptr;
        ucnt = rhs.ucnt;
    }
    return *this;
}

template <class T>
inline
int
LnPtr<T>::linkCount () const
{ 
    return ucnt.linkCount();
}

template <class T>
inline
T&
LnPtr<T>::operator* () const
{
    BL_ASSERT(ptr != 0);
    return *ptr;
}

template <class T>
inline
bool
LnPtr<T>::isNull () const
{
    return ptr == 0;
}

template <class T>
bool
LnPtr<T>::operator== (const LnPtr<T>& rhs) const
{
    return ptr == rhs.ptr;
}

template <class T>
bool
LnPtr<T>::operator!= (const LnPtr<T>& rhs) const
{
    return ptr != rhs.ptr;
}

template <class T>
LnClassPtr<T>::LnClassPtr ()
{}

template <class T>
LnClassPtr<T>::LnClassPtr (T* rhs)
    :
    LnPtr<T>(rhs)
{}

template <class T>
LnClassPtr<T>&
LnClassPtr<T>::operator= (const LnClassPtr<T>& rhs)
{
    LnPtr<T>::operator=(rhs);
    return *this;
}

template <class T>
inline
LnClassPtr<T>&
LnClassPtr<T>::operator= (T* rhs)
{
    LnPtr<T>::operator=(rhs);
    return *this;
}

template <class T>
inline
T*
LnClassPtr<T>::operator->() const
{
    return ptr;
}

#endif /*BL_POINTERS_H*/

---