BoxList.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_BOXLIST_H
#define BL_BOXLIST_H
//
// $Id: BoxList.H,v 1.30 2001/08/06 19:40:27 car Exp $
//
#include <iosfwd>
#include <list>

#include <IntVect.H>
#include <IndexType.H>
#include <Box.H>
//
// Forward declarations.
//
class BoxArray;
class BoxList;

namespace BoxLib
{
    BoxList complementIn (const Box& b, const BoxList& bl);

    //
    //
    BoxList boxDiff (const Box& b1in, const Box& b2);

    BoxList refine (const BoxList&  bl, int ratio);

    BoxList coarsen (const BoxList& bl, int ratio);
    //
    //
    BoxList intersect (const BoxList& bl, const Box& b);
    //
    //
    BoxList intersect (const BoxList& bl, const BoxList& br);

    BoxList accrete (const BoxList& bl, int sz);
}

//
//
std::ostream& operator<< (std::ostream&  os, const BoxList& blist);

//
// :

class BoxList
{
public:

    friend class BoxDomain;

    typedef std::list<Box>::iterator       iterator;
    typedef std::list<Box>::const_iterator const_iterator;
    //
    //
    BoxList ();
    //
    //
    BoxList (const Box& bx);
    //
    //
    explicit BoxList (IndexType btyp);
    //
    //
    explicit BoxList (const BoxArray& ba);

    //
    //
    void push_back (const Box& bn);
    //
    //
    void push_front (const Box& bn);
    //
    //
    void join (const BoxList& blist);
    //
    //
    void catenate (BoxList& blist);
    //
    //
    void clear ();
    //
    //
    int size () const;

    iterator begin ();
    const_iterator begin () const;

    iterator end ();
    const_iterator end () const;

    bool ok () const;
    //
    //
    bool operator== (const BoxList& rhs) const;
    //
    //
    bool operator!= (const BoxList& rhs) const;
    //
    //
    bool isEmpty () const;
    //
    //
    bool isNotEmpty () const;
    //
    //
    bool isDisjoint () const;
    //
    //
    bool contains (const IntVect& v) const;

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

    BoxList& intersect (const Box& b);

    BoxList& intersect (const BoxList& b);
    //
    //
    BoxList& remove (const Box& bx);
    //
    //
    BoxList& remove (iterator bli);
    //
    //
    BoxList& complementIn (const Box&     b,
                           const BoxList& bl);
    //
    //
    BoxList& refine (int ratio);
    //
    //
    BoxList& refine (const IntVect& ratio);
    //
    //
    BoxList& coarsen (int ratio);
    //
    //
    BoxList& coarsen (const IntVect& ratio);
    //
    //
    BoxList& accrete  (int sz);
    //
    //
    BoxList& shift (int dir,
                    int nzones);
    //
    //
    BoxList& shiftHalf (int dir,
                        int num_halfs);
    //
    //
    BoxList& shiftHalf (const IntVect& iv);

    int simplify ();

    int minimize ();
    //
    //
    BoxList& maxSize (int chunk);

    BoxList& maxSize (const IntVect& chunk);
    //
    //
    Box minimalBox () const;
    //
    //
    IndexType ixType () const;

    BoxList& surroundingNodes ();

    BoxList& surroundingNodes (int dir);
    //
    //
    BoxList& enclosedCells ();
    //
    //
    BoxList& enclosedCells  (int dir);
    //
    //
    BoxList& convert (IndexType typ);

protected:
    //
    // The list of Boxes.
    //
    std::list<Box> lbox;
    //
    // Returns a reference to the List<Box>.
    //
    std::list<Box>& listBox();
    //
    // Returns a constant reference to the List<Box>.
    //
    const std::list<Box>& listBox() const;

private:
    //
    // The IndexType of Boxes in the BoxList.
    //
    IndexType btype;
};

inline
BoxList::iterator
BoxList::begin()
{
    return lbox.begin();
}

inline
BoxList::const_iterator
BoxList::begin() const
{
    return lbox.begin();
}

inline
BoxList::iterator
BoxList::end()
{
    return lbox.end();
}

inline
BoxList::const_iterator
BoxList::end() const
{
    return lbox.end();
}

inline
IndexType
BoxList::ixType () const
{
    return btype;
}

inline
void
BoxList::push_back (const Box& bn)
{
    BL_ASSERT(ixType() == bn.ixType());
    lbox.push_back(bn);
}

inline
void
BoxList::push_front (const Box& bn)
{
    BL_ASSERT(ixType() == bn.ixType());
    lbox.push_front(bn);
}

inline
bool
BoxList::isEmpty () const
{
    return lbox.empty();
}

inline
int
BoxList::size () const
{
    return lbox.size();
}

inline
bool
BoxList::isNotEmpty () const
{
    return !lbox.empty();
}

inline
std::list<Box>&
BoxList::listBox()
{
    return lbox;
}

inline
const std::list<Box>&
BoxList::listBox() const
{
    return lbox;
}

inline
void
BoxList::clear ()
{
    lbox.clear();
}

#endif /*BL_BOXLIST_H*/

---