ArrayMapDataFrameManager.h

Go to the documentation of this file.

#ifndef GCP_UTIL_ARRAYMAPDATAFRAMEMANAGER_H
#define GCP_UTIL_ARRAYMAPDATAFRAMEMANAGER_H

#include <string>

#include "gcp/control/code/unix/libunix_src/specific/specificregs.h"

#include "gcp/util/common/DataFrameManager.h"
#include "gcp/util/common/RegMapDataFrameManager.h"
#include "gcp/util/common/RegRange.h"
#include "gcp/util/common/Complex.h"

namespace gcp {
  namespace util {
    
    class CoordRange;
    class Date;
    class RegDescription;
    class BoardDataFrameManager;

    class ArrayMapDataFrameManager : public DataFrameManager {
    public:
      
      virtual ~ArrayMapDataFrameManager();
      
      void operator=(DataFrameManager& manager);
      
      virtual void operator=(ArrayMapDataFrameManager& manager);

      ArrayMapDataFrameManager& operator+=(ArrayMapDataFrameManager& fm);
      
      void writeRegMap(ArrRegMap* aregmap, 
               RegMapDataFrameManager& fm, bool lockFrame);

      void writeRegMap(std::string regmap,
               RegMapDataFrameManager& fm, bool lockFrame);

      void readRegMap(ArrRegMap* aregmap, RegMapDataFrameManager& fm);
      void readRegMap(std::string regmap, RegMapDataFrameManager& fm);

      // Copy the contents of a BoardDataFrameManager to the
      // appropriate place in the array map.

      void writeBoard(BoardDataFrameManager& fm, 
              bool lockFrame);

      void readBoard(BoardDataFrameManager& fm, 
             bool lockFrame);

      //-------------------------------------------------------------
      // Methods to pack a named register.
      //-------------------------------------------------------------
      
      void writeReg(std::string regmap, std::string board, std::string name, 
            unsigned char* data, CoordRange* range=0);
      
      void writeReg(std::string regmap, std::string board, std::string name, 
            signed char* data, CoordRange* range=0);
      
      void writeReg(std::string regmap, std::string board, std::string name, 
            bool* data, CoordRange* range=0);
      
      void writeReg(std::string regmap, std::string board, std::string name, 
            unsigned short* data, CoordRange* range=0);
      
      void writeReg(std::string regmap, std::string board, std::string name, 
            signed short* data, CoordRange* range=0);
      
      void writeReg(std::string regmap, std::string board, std::string name, 
            unsigned int* data, CoordRange* range=0);
      
      void writeReg(std::string regmap, std::string board, std::string name, 
            signed int* data, CoordRange* range=0);
      
      void writeReg(std::string regmap, std::string board, std::string name, 
            float* data, CoordRange* range=0);
      
      void writeReg(std::string regmap, std::string board, std::string name, 
            double* data, CoordRange* range=0);

      void writeReg(std::string regmap, std::string board, std::string name, 
            RegDate::Data* data, CoordRange* range=0);
      
      void writeReg(std::string regmap, std::string board, std::string name, 
            Complex<float>::Data* data, CoordRange* range=0);

      //-------------------------------------------------------------
      // Methods to pack single-valued registers.
      //-------------------------------------------------------------
      
      void writeReg(std::string regmap, std::string board, std::string name, 
            unsigned char data, CoordRange* range=0);
      
      void writeReg(std::string regmap, std::string board, std::string name, 
            signed char data, CoordRange* range=0);
      
      void writeReg(std::string regmap, std::string board, std::string name, 
            bool data, CoordRange* range=0);
      
      void writeReg(std::string regmap, std::string board, std::string name, 
            unsigned short data, CoordRange* range=0);
      
      void writeReg(std::string regmap, std::string board, std::string name, 
            signed short data, CoordRange* range=0);
      
      void writeReg(std::string regmap, std::string board, std::string name, 
            unsigned int data, CoordRange* range=0);
      
      void writeReg(std::string regmap, std::string board, std::string name, 
            signed int data, CoordRange* range=0);
      
      void writeReg(std::string regmap, std::string board, std::string name, 
            float data, CoordRange* range=0);
      
      void writeReg(std::string regmap, std::string board, std::string name, 
            double data, CoordRange* range=0);

      void writeReg(std::string regmap, std::string board, std::string name, 
            RegDate::Data data, CoordRange* range=0);
      
      void writeReg(std::string regmap, std::string board, std::string name, 
            Complex<float>::Data data, CoordRange* range=0);

      //-------------------------------------------------------------
      // Methods to pack a named register.
      //-------------------------------------------------------------

      void writeReg(ArrRegMap* aregmap, RegMapBlock* blk,
            unsigned char* data, CoordRange* range=0);
      
      void writeReg(ArrRegMap* aregmap, RegMapBlock* blk,
            signed char* data, CoordRange* range=0);
      
      void writeReg(ArrRegMap* aregmap, RegMapBlock* blk,
            bool* data, CoordRange* range=0);
      
      void writeReg(ArrRegMap* aregmap, RegMapBlock* blk,
            unsigned short* data, CoordRange* range=0);
      
      void writeReg(ArrRegMap* aregmap, RegMapBlock* blk,
            signed short* data, CoordRange* range=0);
      
      void writeReg(ArrRegMap* aregmap, RegMapBlock* blk,
            unsigned int* data, CoordRange* range=0);
      
      void writeReg(ArrRegMap* aregmap, RegMapBlock* blk,
            signed int* data, CoordRange* range=0);
      
      void writeReg(ArrRegMap* aregmap, RegMapBlock* blk,
            float* data, CoordRange* range=0);
      
      void writeReg(ArrRegMap* aregmap, RegMapBlock* blk,
            double* data, CoordRange* range=0);
      
      void writeReg(ArrRegMap* aregmap, RegMapBlock* blk,
            RegDate::Data* data, CoordRange* range=0);
      
      void writeReg(ArrRegMap* aregmap, RegMapBlock* blk,
            Complex<float>::Data* data, CoordRange* range=0);

      //-------------------------------------------------------------
      // Methods to pack a single-valued register.
      //-------------------------------------------------------------

      void writeReg(ArrRegMap* aregmap, RegMapBlock* blk,
            unsigned char data, CoordRange* range=0);
      
      void writeReg(ArrRegMap* aregmap, RegMapBlock* blk,
            signed char data, CoordRange* range=0);
      
      void writeReg(ArrRegMap* aregmap, RegMapBlock* blk,
            bool data, CoordRange* range=0);
      
      void writeReg(ArrRegMap* aregmap, RegMapBlock* blk,
            unsigned short data, CoordRange* range=0);
      
      void writeReg(ArrRegMap* aregmap, RegMapBlock* blk,
            signed short data, CoordRange* range=0);
      
      void writeReg(ArrRegMap* aregmap, RegMapBlock* blk,
            unsigned int data, CoordRange* range=0);
      
      void writeReg(ArrRegMap* aregmap, RegMapBlock* blk,
            signed int data, CoordRange* range=0);
      
      void writeReg(ArrRegMap* aregmap, RegMapBlock* blk,
            float data, CoordRange* range=0);
      
      void writeReg(ArrRegMap* aregmap, RegMapBlock* blk,
            double data, CoordRange* range=0);
      
      void writeReg(ArrRegMap* aregmap, RegMapBlock* blk,
            RegDate::Data data, CoordRange* range=0);
      
      void writeReg(ArrRegMap* aregmap, RegMapBlock* blk,
            Complex<float>::Data data, CoordRange* range=0);

      //------------------------------------------------------------
      // Methods to read a named register
      //------------------------------------------------------------
      
      void readReg(std::string regmap, std::string board, std::string name, 
           unsigned char* data, CoordRange* range=0);
      
      void readReg(std::string regmap, std::string board, std::string name, 
           signed char* data, CoordRange* range=0);
      
      void readReg(std::string regmap, std::string board, std::string name, 
           bool* data, CoordRange* range=0);
      
      void readReg(std::string regmap, std::string board, std::string name, 
           unsigned short* data, CoordRange* range=0);
      
      void readReg(std::string regmap, std::string board, std::string name, 
           signed short* data, CoordRange* range=0);
      
      void readReg(std::string regmap, std::string board, std::string name, 
           unsigned int* data, CoordRange* range=0);
      
      void readReg(std::string regmap, std::string board, std::string name, 
           signed int* data, CoordRange* range=0);
      
      void readReg(std::string regmap, std::string board, std::string name, 
           float* data, CoordRange* range=0);
      
      void readReg(std::string regmap, std::string board, std::string name, 
           double* data, CoordRange* range=0);
      
      void readReg(std::string regmap, std::string board, std::string name, 
           RegDate::Data* data, CoordRange* range=0);
      
      void readReg(std::string regmap, std::string board, std::string name, 
           Complex<float>::Data* data, CoordRange* range=0);

      //------------------------------------------------------------
      // Methods to read a named register
      //------------------------------------------------------------
      
      void readReg(ArrRegMap* aregmap, RegMapBlock* blk,
           unsigned char* data, CoordRange* range=0);
      
      void readReg(ArrRegMap* aregmap, RegMapBlock* blk,
           signed char* data, CoordRange* range=0);
      
      void readReg(ArrRegMap* aregmap, RegMapBlock* blk,
           bool* data, CoordRange* range=0);
      
      void readReg(ArrRegMap* aregmap, RegMapBlock* blk,
           unsigned short* data, CoordRange* range=0);
      
      void readReg(ArrRegMap* aregmap, RegMapBlock* blk,
           signed short* data, CoordRange* range=0);
      
      void readReg(ArrRegMap* aregmap, RegMapBlock* blk,
           unsigned int* data, CoordRange* range=0);
      
      void readReg(ArrRegMap* aregmap, RegMapBlock* blk,
           signed int* data, CoordRange* range=0);
      
      void readReg(ArrRegMap* aregmap, RegMapBlock* blk,
           float* data, CoordRange* range=0);
      
      void readReg(ArrRegMap* aregmap, RegMapBlock* blk,
           double* data, CoordRange* range=0);
      
      void readReg(ArrRegMap* aregmap, RegMapBlock* blk,
           RegDate::Data* data, CoordRange* range=0);
      
      void readReg(ArrRegMap* aregmap, RegMapBlock* blk,
           Complex<float>::Data* data, CoordRange* range=0);

      // Return the value of the current register in a range, cast as
      // a double

      double getRegVal(RegRange& range, bool lockFrame);

      // Return the value of the requested register index, cast as a double

      double getRegVal(RegDescription& desc);

      // Return true if this frame only contains archived registers

      inline bool archivedOnly() {return archivedOnly_;};

      // Return a pointer to the array map

      inline ArrayMap* arrayMap() {
    return arrayMap_;
      }

      unsigned int getId(unsigned nanoSecondInterval);

      int byteOffsetInFrameOf(std::string regmap, std::string board, 
                  std::string block, Coord* coord=0);

      // Get a pointer to the start of the register described in a
      // RegDescription, in our data frame.

      void* getPtr(RegDescription& desc);

    protected:
      
      ArrayMap* arrayMap_;       // The GCP array map 
      
      bool archivedOnly_;           // True if this frame should
                    // contain only archived registers
      ArrayMapDataFrameManager(bool archivedOnly_=false);

      int byteOffsetInFrameOf(ArrRegMap* aregmap);
      int byteOffsetInFrameOf(std::string regmap, std::string board);
      int byteOffsetInFrameOf(ArrRegMap* aregmap, RegMapBlock* blk, 
                  Coord* coord=0);
      
      void packData(ArrRegMap* aregmap, RegMapBlock* blk, 
            void* data, CoordRange* range, 
            DataType::Type type, bool lockFrame=true);
      void packData(std::string regmap, std::string board, std::string block, 
            void* data, CoordRange* range, 
            DataType::Type type, bool lockFrame=true);

      void unpackData(ArrRegMap* aregmap, RegMapBlock* blk, 
              void* data, CoordRange* range, 
              DataType::Type type, bool lockFrame=true);
      void unpackData(std::string regmap, std::string board, std::string block, 
              void* data, CoordRange* range, 
              DataType::Type type,bool lockFrame=true);
      
      void checkType(std::string regmap, std::string board, std::string block, 
             DataType::Type type,
             CoordRange* range);

      void checkType(ArrRegMap* aregmap, RegMapBlock* blk, DataType::Type type,
             CoordRange* range);

    public:
      RegMapBlock* getReg(std::string regmap, std::string board, 
              std::string block);

      RegMapBlock* findReg(std::string regmap, std::string board, 
               std::string block);

      ArrRegMap* getArrReg(std::string regmap);

    private:
      bool regMapIsPresent(RegMap* regmap);

      bool boardIsPresent(RegMapBoard* brd);

      bool boardIsFlagged(ArrRegMap* aregmap, RegMapBoard* brd);

      bool blockIsPresent(RegMapBlock* blk);

    }; // End class ArrayMapDataFrameManager
    
  } // End namespace util
} // End namespace gcp



#endif // End #ifndef GCP_UTIL_ARRAYMAPDATAFRAMEMANAGER_H