RegDescription.h

Go to the documentation of this file.

#ifndef SZA_UTIL_REGDESCRIPTION_H
#define SZA_UTIL_REGDESCRIPTION_H

#include "carma/szautil/ArrayMapBase.h"
#include "carma/szautil/CoordAxes.h"
#include "carma/szautil/CoordRange.h"
#include "carma/szautil/Range.h"
#include "carma/szautil/RegAxisRange.h"

#include "carma/szaarrayutils/szaregs.h"

#include <iostream>

namespace sza {
  namespace util {
    
    class RegParser;

    class RegDescription {
    public:
      
      RegDescription(bool archivedOnly_=false, ArrayMap* arrayMap=0);

      RegDescription(bool archivedOnly_, RegMapBlock* block);
      
      RegDescription(RegDescription& desc);
      RegDescription(const RegDescription& desc);
      
      void operator=(RegDescription& desc);
      void operator=(const RegDescription& desc);

      virtual ~RegDescription();

      void initialize();

      void reset();

      void setTo(std::string regmap_name, 
                 std::string board_name, 
                 std::string block_name,
                 RegAspect aspect,
                 RegInteg integ,
                 Coord* coord=0, 
                 unsigned n=0);

      void setTo(std::string regmap_name, 
                 std::string board_name, 
                 std::string block_name,
                 RegAspect aspect,
                 RegInteg integ,
                 CoordRange& coordRange);

      void setCoord(Coord& coord);

      void setOutputMode(RegOutputMode mode);

      // A method for printing this object's register specification on
      // an output stream

      friend std::ostream& operator<<(std::ostream& os, 
                                                 RegDescription& desc);

      void output(OutputStream* stream, RegOutputMode mode);

      bool rangeIsValid(CoordRange& range);
      bool rangeIsValid(CoordRange* range);

      unsigned nEl(CoordRange* range=0);
      unsigned nByte(CoordRange* range=0);

      unsigned fastestNel();

      CoordRange range() {
        return range_;
      }

      CoordRange* getRangePtr() {
        return &range_;
      }

      CoordAxes axes() {
        return axes_;
      }

      std::vector<Range<unsigned> > getElementRanges(CoordRange* range=0);

      std::vector<Range<unsigned> > getSlotRanges(CoordRange* range=0);

      std::vector<Range<unsigned> > getByteRanges(CoordRange* range=0);

      unsigned nSlot(CoordRange* range=0);

      int startSlot(CoordRange* range=0);
      int stopSlot(CoordRange* range=0);

      int iSlot() {
        return iSlot_;
      }

      int iRegMap() {
        return iRegMap_;
      }

      int iBoard() {
        return iBoard_;
      }

      int iBlock() {
        return iBlock_;
      }

      ArrRegMap* regMap();

      RegAspect aspect() {
        return aspect_;
      }

      std::string aspectName();

      void setAspect(RegAspect aspect) {
        aspect_ = aspect;
      }
   
      RegInteg integ() {
        return integ_;
      }

      std::string integName();

      void setInteg(RegInteg integ) {
        integ_ = integ;
      }

      inline ArrayMap* arrayMap() {
        return arrayMap_;
      }

      RegMapBlock* block();

      std::string blockName();
      std::string boardName();
      std::string regMapName();

      void begin();

      bool isEnd();

      const RegDescription& operator++();
      
      unsigned currentSlot();

      unsigned currentElement();

      Coord currentCoord();

      // True if the selected range of elements in this descriptor
      // contains the range in the passed descriptor

      bool contains(RegDescription& desc);

      inline long oldestVisible() {
        return oldestVisible_;
      }

      inline bool isFirst() {
        return first_;
      }

      void setFirst(bool first);
      void setOldestVisible(long oldest);
      void resetOldestVisible();
      void decreaseOldestVisible(long oldest);
      void increaseOldestVisible(long oldest);

      CoordAxes  axes_;    // An axis specifier for this register

    private:

      friend class RegParser;

      // A static array map used by all objects of this type

      ArrayMapBase arrayMapBase_;
      ArrayMap* arrayMap_;

      // Per-object members

      bool archivedOnly_; // True if this class is to manage only
                          // archived registers

      RegOutputMode outputMode_; // A specification for how this
                                 // register description should be
                                 // written on output

      int iRegMap_;        // The index of the specified register map in the
                           // array map

      int iBoard_;         // The index of the specified board in the
                           // register-map

      int iBlock_;         // The index of the specified block on the
                           // regmap board

      int iSlot_;          // The frame index of the first element of
                           // this register.
                           //
                           // NB: This is the frame offset of the
                           // _first_ element of this register, and
                           // not the offset of the first requested
                           // element (i.e., of range_.startCoord())

      unsigned nEl_;       // The total number of elements requested

      unsigned size_;      // The number of slots per register. This
                           // is 1 unless aspect!=REG_PLAIN, in which
                           // case it becomes 2
      RegAspect aspect_;   // The quantity to derive from complex or
                           // utc register pairs

      RegInteg integ_;     // Integration status of this register

      int iByte_;          // The byte index into the array map of the
                           // first element of the requested register.
                           //
                           // NB: This is the offset of the _first_
                           // element of this register, and not the
                           // offset of the first requested element
                           // (i.e., of range_.startCoord())
      
      unsigned nBytePerEl_;// The number of bytes per element of this
                           // register
      
      CoordRange range_;   // An index-range specifier

      RegAxisRange* axisRange_; // An axis-range for iterating
      
      // This is just a utility member for use in plotting interface.

      long oldestVisible_;
      bool first_;

    }; // End class RegDescription
    
  } // End namespace util
} // End namespace sza



#endif // End #ifndef SZA_UTIL_REGDESCRIPTION_H