PArray.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_PARRAY_H
#define BL_PARRAY_H
//
// $Id: PArray.H,v 1.23 2001/07/31 22:43:19 lijewski Exp $
//
#include <Array.H>

//
// :

enum PArrayPolicy
{
    PArrayNoManage = 0,
    PArrayManage   = 1
};

//
// :

template <class T>
class PArray
{
public:

    explicit PArray (PArrayPolicy _managed = PArrayNoManage);

    explicit PArray (int          len,
                     PArrayPolicy _managed = PArrayNoManage);

    ~PArray ();
    //
    //
    bool defined (int i) const;

    const T& operator[] (int i) const;

    T& operator[] (int i);

    const T& get (int i) const;

    T& get (int i);

    void set (int i,
              T*  elem);
    //
    //
    int size () const;

    void clear ();

    void clear (int i);

    void resize (int newsize);

    void resize (int          newsize,
                 PArrayPolicy newmanagedpolicy);

    T* remove (int i);

protected:
    //
    // The underlying representation.
    //
    Array<void*> vp;
    //
    // The memory management policy.
    //
    PArrayPolicy managed;

public:
    //
    // Disallow these. FIXME
    //
    PArray (const PArray<T>&);
    // PArray<T> operator= (const PArray<T>&);
};

template <class T>
PArray<T>::PArray (const PArray<T>& c)
{
    BL_ASSERT(c.size()==0);
}

template <class T>
PArray<T>::PArray (PArrayPolicy _managed)
    :
    managed(_managed)
{}

template <class T>
inline
bool
PArray<T>::defined (int i) const
{
    return vp[i] != 0;
}

template <class T>
inline
const T&
PArray<T>::operator[] (int i) const
{
    BL_ASSERT(vp[i] != 0);
    return *((T*)(vp[i]));
}

template <class T>
inline
T&
PArray<T>::operator[] (int i)
{
    BL_ASSERT(vp[i] != 0);
    return *((T*)(vp[i]));
}

template <class T>
inline
const T&
PArray<T>::get (int i) const
{
    BL_ASSERT(vp[i] != 0);
    return *((T*)(vp[i]));
}

template <class T>
inline
T&
PArray<T>::get (int i)
{
    BL_ASSERT(vp[i] != 0);
    return *((T*)(vp[i]));
}

template <class T>
inline
void
PArray<T>::set (int i,
                T*  elem)
{
    BL_ASSERT(vp[i] == 0);
    vp[i] = elem;
}

template <class T>
inline
int
PArray<T>::size () const
{
    return vp.size();
}

template <class T>
T*
PArray<T>::remove (int i)
{
    BL_ASSERT(vp[i] != 0);
    void* tmp = vp[i];
    vp[i]     = 0;
    return (T*) tmp;
}

template <class T>
void
PArray<T>::clear (int n)
{
    if (managed)
        delete ((T*)(vp[n]));
    vp[n] = 0;
}

template <class T>
PArray<T>::PArray (int          len,
                   PArrayPolicy _managed)
    :
    vp(len),
    managed(_managed)
{
    for (int i = 0; i < size(); i++)
        vp[i] = 0;
}

template <class T>
void
PArray<T>::clear ()
{
    if (managed)
    {
        for (int i = 0; i < size(); ++i)
        {
            delete ((T*)(vp[i]));
        }
    }
    for (int i = 0; i < size(); ++i)
        vp[i] = 0;
}

template <class T>
PArray<T>::~PArray ()
{
    clear();
}

template <class T>
void
PArray<T>::resize (int newlen)
{
    void** ovp = vp.size() ? &vp[0] : 0;

    int oldlen = vp.size();

    vp.resize(newlen);

    for (int i = oldlen; i < newlen; ++i)
        vp[i] = 0;

    if (managed)
    {
        for (int i = newlen; i < oldlen; i++)
        {
            delete ((T*)(ovp[i]));
            ovp[i]  = 0;
        }
    }
}

template <class T>
void
PArray<T>::resize (int          newlen,
                   PArrayPolicy newmanagedpolicy)
{
    if (newmanagedpolicy == managed)
    {
        resize(newlen);
    }
    else
    {
        clear();
        resize(newlen);
        managed = newmanagedpolicy;
    }
}

#endif /*BL_PARRAY_H*/

---