RegDescription.h

Go to the documentation of this file.

#ifndef GCP_UTIL_REGDESCRIPTION_H
#define GCP_UTIL_REGDESCRIPTION_H

#include "gcp/util/common/ArrayMapBase.h"
#include "gcp/util/common/CoordAxes.h"
#include "gcp/util/common/CoordRange.h"
#include "gcp/util/common/Range.h"
#include "gcp/util/common/RegAxisRange.h"

#include "gcp/control/code/unix/libunix_src/common/genericregs.h"

#include <iostream>

namespace gcp {
  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);
      
      RegDescription& operator=(RegDescription& desc);
      RegDescription& operator=(const RegDescription& desc);

      void clear();  
      
      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& gcp::util::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 gcp




#endif // End #ifndef GCP_UTIL_REGDESCRIPTION_H