GridBoxList.h

Go to the documentation of this file.

// -*- C++ -*-

#ifndef _included_GridBoxList_h
#define _included_GridBoxList_h

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

#include <iosfwd>
#include <cstdlib>
#include <cstring>

#ifndef DefGridBoxListSize
#define DefGridBoxListSize (128)
#endif

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

    // Label constructor explicit to avoid implicit conversions to this class
    explicit GridBoxList(const unsigned int maxnum)
        : Bucket<GridBox>(maxnum) {}

    inline GridBoxList(const void* package, const unsigned int size, 
                       const int n)
        : Bucket<GridBox>(package, size, n) {}

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

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

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

    /*************************************************************************/
    inline GridBoxList* alias()
        { return dynamic_cast<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); 

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:
    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; 
    }
   
public:
    /*************************************************************************/
    void bboxlist(BBoxList& bbl, const int olap);
    void bboxlist(BBoxList& bbl, const short* olap, const int extgh);
};

std::ostream& operator<<(std::ostream& os, const GridBoxList& gbl);
std::ofstream& operator<<(std::ofstream& ofs, const GridBoxList& gbl);
std::stringstream& operator<<(std::stringstream& ofs, const GridBoxList& gbl);

std::ifstream& operator>>(std::ifstream& ifs, GridBoxList& gbl);
std::stringstream& operator>>(std::stringstream& ifs, GridBoxList& gbl);

#endif

---