Blockstructured Adaptive Mesh Refinement in object-oriented C++

---

       

---

GridBoxList.h

Go to the documentation of this file.

#ifndef _included_GridBoxList_h
#define _included_GridBoxList_h

#include "DAGHDefaults.h"
#include "BBoxList.h"
#include "GridBox.h"
#include "BucketType.h"
#include "ObjectCounter.h"

#ifndef DefGridBoxListSize
#define DefGridBoxListSize (128)
#endif

#define GridBoxListNULL ((GridBoxList *) NULL)

typedef Bucket<GridBox> Bucket_GridBox;

class GridBoxList : public Bucket<GridBox>, public ObjectCounter
  {
   friend ostream& operator<<(ostream&, const GridBoxList&);
   friend ofstream& operator<<(ofstream&, const GridBoxList&);
   friend ifstream& operator>>(ifstream&, GridBoxList&);
   friend strstream& operator<<(strstream&, const GridBoxList&);
   friend strstream& operator>>(strstream&, GridBoxList&);

   int num;

private:
   static inline void copytypedata(GridBox* to, const GridBox* from)
     { memcpy((void *) to, (void *) from, sizeof(GridBox)); }

   /*************************************************************************/
   inline void setstats(void)
     {num=0;for (register GridBox *g=first();g;g=next())num++;}

public:
   /*************************************************************************/
   inline GridBoxList()
     : Bucket<GridBox>(DefGridBoxListSize), num(0) {}

   // We need dumarg because the SP2 does implicit conversions
   // from anything to this class
   inline GridBoxList(const int maxnum, const int dumarg)
     : Bucket<GridBox>(maxnum), num(0) {}

   inline GridBoxList(const void* package, const int size, 
               const int n)
     : Bucket<GridBox>(package, size, n), num(0) { setstats(); }

   inline GridBoxList(const GridBoxList& other)
     : Bucket<GridBox>(other), num(other.num) {}

   /*************************************************************************/
   GridBoxList& operator = (const GridBoxList&);

   /*************************************************************************/
   inline ~GridBoxList(void) {}

   /*************************************************************************/
   inline GridBoxList *alias()
        { return((GridBoxList *) ObjectCounter::alias()); }

public:
   /*************************************************************************/
   /*** GBL operators ***/
   /*************************************************************************/
   int difference(GridBoxList& gbl, const GridBox& lhs, 
                   const GridBox& rhs);
   int intersection(GridBoxList& gbl, const GridBox& lhs, 
                    const GridBox& rhs);
   void operator -= (const GridBoxList &rhs); 
   void operator *= (const GridBoxList &rhs); 
   //GridBoxList *operator - (const GridBoxList &rhs); /* Abs Difference */
   //GridBoxList *operator * (const GridBoxList &rhs); /* Intersection */
   //GridBoxList *operator + (const GridBoxList &rhs); /* Union */

   /*************************************************************************/
   /*** GBL operations with a BBox & BBoxList ***/
   /*************************************************************************/
private: 
   //void operator *= (const BBox& rhs); /* Intersection */
   //GridBoxList *operator * (const BBox& rhs); /* Intersection */
   //GridBoxList *operator * (const BBoxList& rhs); /* Intersection */
 
public:
   /*************************************************************************/
   void intersect(const BBox& rhs, GridBoxList& gbl);
   void intersect(const BBox& rhs, GridBoxList& gbl, 
                  const int olap, const int extgh=0);
   void intersect(const BBoxList& rhs, GridBoxList& gbl, 
                  const int olap, const int extgh=0);
   void intersect(const BBox& rhs, GridBoxList& gbl, 
                  const short* olap, const int extgh=0);
   void intersect(const BBoxList& rhs, GridBoxList& gbl,
                  const short* olap, const int extgh=0);

   /*************************************************************************/
   /*** Query functions ***/
   /*************************************************************************/
public:
   inline int isempty() const { return(num == 0); }
   inline int number() const { return(num); }

   int maxindex(void);

   int index(const BBox& bbv);
   const GridBox& find(const BBox& bb);

   /*************************************************************************/
public:
   inline void setindex(void)
     { register int idx=0; 
       for (register GridBox *g=first();g;g=next()) g->index=idx++; }
   inline void setowner(const int p)
     { for (register GridBox *g=first();g;g=next()) g->owner=p; }
   
   /*************************************************************************/
   inline void empty(void)
     { Bucket<GridBox>::empty(); num = 0; }

   /*************************************************************************/
   inline GridBox *add() 
     { num++; return (Bucket<GridBox>::add()); }
   inline GridBox *add(const GridBox& gb) 
     { num++; return (Bucket<GridBox>::add(gb)); }
   inline GridBox *insert(const GridBox& gb)
     { num++;  return (Bucket<GridBox>::insert(gb)); }
   inline void remove(void)
     { if (current()) { num--; Bucket<GridBox>::remove(); }}

public:
   /*************************************************************************/
   void bboxlist(BBoxList& bbl, const int olap);
   void bboxlist(BBoxList& bbl, const short* olap, const int extgh);
  };

ostream&  operator << (ostream& os, const GridBoxList& gbl);
ofstream& operator << (ofstream& ofs, const GridBoxList& gbl);
strstream& operator << (strstream& ofs, const GridBoxList& gbl);

ifstream& operator >> (ifstream& ifs, GridBoxList& gbl);
strstream& operator >> (strstream& ifs, GridBoxList& gbl);

#endif

---

Quickstart     Users Guide     Programmers Reference     Installation      Examples     Download

---

AMROC Main      Home      Contact

last update: 06/01/04