BoxArray.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_BOXARRAY_H
#define BL_BOXARRAY_H
//
// $Id: BoxArray.H,v 1.31 2001/08/21 19:01:51 lijewski Exp $
//
#if defined(BL_OLD_STL)
#include <stddef.h>
#else
#include <cstddef>
#endif

#include <IndexType.H>
#include <BoxList.H>
#include <Array.H>
#include <Pointers.H>

class BoxArray;

namespace BoxLib
{
    //
    //
    BoxArray boxComplement (const Box& b1in, const Box& b2);
    //
    //
    BoxArray complementIn (const Box& b, const BoxArray& ba);
    //
    //
    BoxArray intersect (const BoxArray& ba, const Box& b);
    //
    //
    BoxArray intersect (const BoxArray& lhs, const BoxArray& rhs);
}

//
//
std::ostream& operator<< (std::ostream& os, const BoxArray& ba);

//
// :

class BoxArray
{
public:
    //
    //
    BoxArray ();
    //
    //
    BoxArray (const Box& bx);
    //
    //
    explicit BoxArray (size_t size);
    //
    //
    BoxArray (const Box* bxvec,
              int        nbox);
    //
    //
    explicit BoxArray (const BoxList& bl);
    //
    //
    BoxArray (const BoxArray& bs);
    //
    //
    BoxArray& operator= (const BoxArray& rhs);
    //
    //
    ~BoxArray ();

    void define (const BoxList& bl);

    void define (const BoxArray& bs);
    //
    //
    void clear ();
    //
    //
    void resize (int len);
    //
    //
    int size () const;

    long numPts() const;

    void readFrom (std::istream& is);
    //
    //
    std::ostream& writeOn (std::ostream&) const;
    //
    //
    bool operator== (const BoxArray& rhs) const;
    //
    //
    bool operator!= (const BoxArray& rhs) const;
    //
    //
    BoxArray& maxSize (int block_size);
    //
    //
    BoxArray& refine (int refinement_ratio);
    //
    //
    BoxArray& refine (const IntVect& refinement_ratio);
    //
    //
    BoxArray& coarsen (int refinement_ratio);
    //
    //
    BoxArray& coarsen (const IntVect& refinement_ratio);
    //
    //
    BoxArray& grow (int n);
    //
    //
    BoxArray& grow (const IntVect& iv);

    BoxArray& grow (int idir,
                    int n_cell);

    BoxArray& surroundingNodes ();

    BoxArray& surroundingNodes (int dir);
    //
    //
    BoxArray& enclosedCells ();
    //
    //
    BoxArray& enclosedCells  (int dir);
    //
    //
    BoxArray& convert (IndexType typ);
    //
    //
    BoxArray& convert (Box (*fp)(const Box&));
    //
    //
    BoxArray& shift (int dir,
                     int nzones);
    //
    //
    BoxArray& shiftHalf (int dir,
                         int num_halfs);
    //
    //
    BoxArray& shiftHalf (const IntVect &iv);
    //
    //
    void set (int        i,
              const Box& ibox);
    //
    //
    const Box& operator[] (int index) const;
    //
    //
    const Box& get (int index) const;

    bool ok () const;
    //
    //
    bool isDisjoint () const;
    //
    //
    BoxList boxList () const;
    //
    //
    bool contains (const IntVect& v) const;

    bool contains (const Box& b) const;
    //
    //
    bool contains (const BoxArray& bl) const;
    //
    //
    Box minimalBox () const;

    void reserve (long _truesize);

protected:

    class Ref
    {
        friend class BoxArray;
        //
        // Constructors to match those in BoxArray ....
        //
        Ref ();

        Ref (size_t size);

        Ref (const BoxList& bl);

        Ref (std::istream& is);

        Ref (const Ref& rhs);
        //
        // Some defines()s to match those in BoxArray.
        //
        void define (const BoxList& bl);

        void define (std::istream& is);
        //
        // The data -- an Array of Boxes.
        //
        Array<Box> m_abox;   
    };
    //
    // Make `this' unique.
    //
    void uniqify ();
    //
    // The data -- a reference-counted pointer to a Ref.
    //
    LnClassPtr<Ref> m_ref;
};

inline
int
BoxArray::size () const
{
    return m_ref->m_abox.size();
}

inline
const Box&
BoxArray::operator[] (int index) const
{
    return m_ref->m_abox.get(index);
}

inline
const Box&
BoxArray::get (int index) const
{
    return m_ref->m_abox.get(index);
}

#endif /*BL_BOXARRAY_H*/

---