PackedGridDataBucket.h

Go to the documentation of this file.

// -*- C++ -*-

#ifndef _included_PackedGridDataBucket_h
#define _included_PackedGridDataBucket_h

#include "DAGHParams.h"
#include "DAGHDefaults.h"

#include "DAGHSfc.h"
#include "BBox.h"

#include "PackedDataBucketVoid.h"
#include "ObjectCounter.h"

#include <iosfwd>
#include <cstring>

/* Bucket/Message Types */
#define DAGHSingle      (1)
#define DAGHPacked      (2)

#ifndef DAGHBktGFNameWidth
#define DAGHBktGFNameWidth      (32)
#endif

struct gdhdr
  {
   friend std::ostream& operator<<(std::ostream& os, const struct gdhdr& hdr);

   short int type;
   short int owner;     
   short unsigned gfid;
   short gfdatatype;
   short gfstaggertype;
   char gfname[DAGHBktGFNameWidth];
   BBox bbox;
   short int time;
   int time_value;
   char physical_time[sizeof(double)];
   short int level;     
   short int index;     

   inline gdhdr() {};
   gdhdr(struct gdhdr& other);

   gdhdr(const BBox& bb, 
         const unsigned gf, const int gft, const int gfs, const char* gfn,
         const int t, const int tv, const int l, const int index,
         const int who, const int type);

   static unsigned gdbsize(const unsigned dsize);
  };

#define GridDataBucketVoidNULL  ((GridDataBucketVoid *)0)

class GridDataBucketVoid : public DataBucketVoid, public ObjectCounter
  {
   int bkttype;

private:
   GridDataBucketVoid(const GridDataBucketVoid&);       
   void operator = (const GridDataBucketVoid&);

public:
   inline GridDataBucketVoid* alias()
        { return((GridDataBucketVoid *) ObjectCounter::alias()); }

   GridDataBucketVoid(const BBox& bb, const unsigned gf,
           const int time, const int time_value, const int level, const int index,
           const int who, const unsigned datasize, const int type);

   GridDataBucketVoid(const BBox& bb, const unsigned gf, const int gfdtype, 
                      const int gfstype, const char* gfname, const int time, 
                      const int time_value, const int level, const int index,
                       const int who, const unsigned datasize, const int type);

   inline GridDataBucketVoid(const int n, unsigned* dsizes, const int type)
        : DataBucketVoid(sizeof(struct gdhdr), dsizes, n), bkttype(type) {}

   void add(const BBox& bb, const unsigned gf, const int time, const int time_value,  
            const int level, const int index, const int who, const int n);

   void add(const BBox& bb, const unsigned gf, const int gfdtype, const int gfstype,
            const char* gfname, const int time, const int time_value, const int level,  
            const int index, const int who, const int n);

   inline GridDataBucketVoid(const void* package)
         :DataBucketVoid((const union drecord *) package) 
   { bkttype = ((struct gdhdr *) DataBucketVoid::head())->type; }

   inline GridDataBucketVoid(void* package)
        :DataBucketVoid((union drecord *) package) 
   { bkttype = ((struct gdhdr *) DataBucketVoid::head())->type; }

   inline GridDataBucketVoid(const void* package, const int n)
         :DataBucketVoid((const union drecord *) package, n) 
   { bkttype = ((struct gdhdr *) DataBucketVoid::head())->type = DAGHSingle; }

   GridDataBucketVoid(const struct gdhdr& other, const unsigned datasize);

   inline int type() const { return (bkttype); }

   inline struct gdhdr *head()
        { return ( (struct gdhdr *) DataBucketVoid::head() ); }
   inline struct gdhdr *head(const int i)
        { return ( (struct gdhdr *) DataBucketVoid::head(i) ); }

   inline BBox const &bbox() const
        { return (((struct gdhdr *) DataBucketVoid::head())->bbox); }
   inline BBox const &bbox(const int i) const
        { return (((struct gdhdr *) DataBucketVoid::head(i))->bbox); }

   inline short int owner() const
        { return (((struct gdhdr *) DataBucketVoid::head())->owner); }
   inline short int owner(const int i) const
        { return (((struct gdhdr *) DataBucketVoid::head(i))->owner); }

   inline short int time() const
        { return ( ((struct gdhdr *) DataBucketVoid::head())->time); }
   inline short int time(const int i) const
        { return ( ((struct gdhdr *) DataBucketVoid::head(i))->time); }

   inline short int time_value() const
        { return ( ((struct gdhdr *) DataBucketVoid::head())->time_value); }
   inline short int time_value(const int i) const
        { return ( ((struct gdhdr *) DataBucketVoid::head(i))->time_value); }

   inline short int level() const
        { return ( ((struct gdhdr *) DataBucketVoid::head())->level); }
   inline short int level(const int i) const
        { return ( ((struct gdhdr *) DataBucketVoid::head(i))->level); }

   inline short int index() const
        { return ( ((struct gdhdr *) DataBucketVoid::head())->index); }
   inline short int index(const int i) const
        { return ( ((struct gdhdr *) DataBucketVoid::head(i))->index); }

   inline short unsigned gfid() const
        { return ( ((struct gdhdr *) DataBucketVoid::head())->gfid); }
   inline short unsigned gfid(const int i) const
        { return ( ((struct gdhdr *) DataBucketVoid::head(i))->gfid); }

   inline short gfdatatype() const
        { return ( ((struct gdhdr *) DataBucketVoid::head())->gfdatatype); }
   inline short gfdatatype(const int i) const
        { return ( ((struct gdhdr *) DataBucketVoid::head(i))->gfdatatype); }

   inline short gfstaggertype() const
        { return ( ((struct gdhdr *) DataBucketVoid::head())->gfstaggertype); }
   inline short gfstaggertype(const int i) const
        { return ( ((struct gdhdr *) DataBucketVoid::head(i))->gfstaggertype); }

   inline char *gfname() const
        { return ( ((struct gdhdr *) DataBucketVoid::head())->gfname); }
   inline char *gfname(const int i) const
        { return ( ((struct gdhdr *) DataBucketVoid::head(i))->gfname); }

   inline void setgfname(const char *name) const
   { std::strncpy(((struct gdhdr *)DataBucketVoid::head())->gfname,
     name,DAGHBktGFNameWidth-1); }
   inline void setgfname(const char *name, const int i) const
   { std::strncpy(((struct gdhdr *)DataBucketVoid::head(i))->gfname,
     name,DAGHBktGFNameWidth-1); }
  };

template <class Type>
class GridDataBucket: public GridDataBucketVoid
  {
private:
   GridDataBucket(const GridDataBucket<Type>&); 
   void operator = (const GridDataBucket<Type>&);

public:
   inline GridDataBucket(const BBox& bb, const unsigned gf,
          const int time, const int time_value, const int level, const int index, const int who, 
          const int type=DAGHSingle)
        : GridDataBucketVoid(bb, gf, time, time_value, level, index, who, 
                             sizeof(Type), type) {}

   inline GridDataBucket(const BBox& bb, const unsigned gf, 
          const int gfdtype, const int gfstype, const char* gfname,
          const int time, const int time_value, const int level, const int index, const int who, 
          const int type=DAGHSingle)
        : GridDataBucketVoid(bb, gf, gfdtype, gfstype, gfname, time, time_value,  
                             level, index, who, sizeof(Type), type) {}

   inline GridDataBucket(const void* package) 
        : GridDataBucketVoid(package) {}

   inline GridDataBucket(void* package) 
        : GridDataBucketVoid(package) {}

   inline GridDataBucket(const void* package, const int n) 
        : GridDataBucketVoid(package, n) {}

   inline GridDataBucket(const int n, unsigned* dsizes, 
                         const int type) //=DAGHSingle)
        : GridDataBucketVoid(n, dsizes, type) {}

   inline Type const *data() const
        { return ( (Type *) DataBucketVoid::data() ); }
   inline Type *data(void)
        { return ( (Type *) DataBucketVoid::data() ); }

   inline Type const *data(const int i) const
        { return ( (Type *) DataBucketVoid::data(i) ); }
   inline Type *data(const int i)
        { return ( (Type *) DataBucketVoid::data(i) ); }
  };

#endif

---