XMLDataFrameManager.h

Go to the documentation of this file.

#ifndef GCP_RECEIVER_XMLDATAFRAMEMANAGER_H
#define GCP_RECEIVER_XMLDATAFRAMEMANAGER_H

// C header files from the array control code

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

#include "Utilities/MuxXMLDatacard.h"

#include "gcp/util/common/RegMapDataFrameManager.h"

#include "gcp/util/common/Exception.h"

#include <map>
#include <vector>

namespace gcp {
  namespace receiver {
      
    class DataFrame;
      
    class XMLDataFrameManager : 
      public gcp::util::RegMapDataFrameManager {

      public:
    
      XMLDataFrameManager(XMLDataFrameManager& fm);
    
      XMLDataFrameManager(bool archivedOnly=false);
    
    
      virtual void setTo(MuxReadout::MuxXMLFile *xml);

      virtual ~XMLDataFrameManager();
    
      void initialize(bool archivedOnly=false, 
              gcp::util::DataFrame* frame = 0);
    
      void reinitialize();

      class XMLRegisterMap {
      public:
        
    virtual void 
      set(unsigned int addr, int value, unsigned int boardNum) = 0;

    virtual void 
      set(unsigned int addr, double value, unsigned int boardNum) = 0;

    virtual void 
      set(std::string name, double value, unsigned int boardNum) {};

    virtual void 
      set(std::string name, std::vector<double> &values, 
          unsigned int boardNum) {};

    virtual void 
      set(std::string name, int value, unsigned int boardNum) = 0;

    virtual void 
      set(std::string name, std::vector<int> &values, 
          unsigned int boardNum) {};

    virtual void 
      set(std::string name, std::string value, 
          unsigned int boardNum) = 0;

    virtual void write() = 0;

    template <class valueType> class RegisterList {
    public:
          
      RegisterList(RegMapDataFrameManager* frame, 
               unsigned int index1Size=0, 
               unsigned int index2Size=0, 
               unsigned int index3Size=0) :
        frame_(frame), minMappedAddress_(0), index1Size_(index1Size), 
        index2Size_(index2Size), index3Size_(index3Size) {};
              
    private:
          
      bool addMapped(char* boardName, char* regName)
        {
          RegMapBlock* regBlock = NULL;
          try {
        regBlock = frame_->findReg(boardName, regName);
          } catch (...) {
        ReportError("Board" << boardName << " register " 
                << regName << " not found.");
          }

          if(regBlock != NULL) {
        registers_.push_back(regBlock);
        unsigned int maxIndex;
        if(index3Size_) {
          maxIndex = index3Size_ * index2Size_ * index1Size_;
        } else if (index2Size_) {
          maxIndex = index2Size_ * index1Size_;
        } else {
          maxIndex = index1Size_;
        }

        std::vector<valueType>* buffPtr = 
          new std::vector<valueType>(maxIndex);

        buffers_.push_back(buffPtr);

        return true;

          } else {
        ReportError("Board " << boardName << " register " 
                << regName << " not found");
        return false;
          }
        }
                
    public:
                
      void add(char* boardName, char* regName) 
        {
          if(addMapped(boardName, regName)) {
        minMappedAddress_++;
          }
        }
                
      void add(char* boardName, char* regName, unsigned int address)
        {
          if((addressToIndex_.find(address) != addressToIndex_.end()) 
         || (address < minMappedAddress_)) {
        ReportError("Duplicate register address " << regName 
                << " " << address);
        return;
          }

          addressToIndex_[address] = registers_.size();

          addMapped(boardName, regName);
        }   
                
      void add(char* boardName, char* regName, std::string xmlTag)
        {
          if(xmlTagToIndex_.find(xmlTag) != xmlTagToIndex_.end()) {
        ReportError("Duplicate register tag " << regName 
                << " " << xmlTag);
        return;
          }
                  
          xmlTagToIndex_[xmlTag] = registers_.size();
          addMapped(boardName, regName);
        }
                            
      void setResolved(unsigned int registerNum, valueType value, 
               unsigned int index1=0, unsigned int index2=0, 
               unsigned int index3=0) 
        {
          if(registerNum >= buffers_.size()) {
        ReportError("Register number " << registerNum 
                << " out of range ");
        return;
          }
              
          unsigned int index;
          if(index3Size_) {
        index = index1*index2Size_*index3Size_ + 
          index2*index3Size_ + index3;
          } else if(index2Size_) {
        index = index1 * index2Size_ + index2;
          } else {
        index = index1;
          }

          (*static_cast< std::vector<valueType>* >(buffers_[registerNum]))[index] = value;
        };
            
      void set(unsigned int registerNum, valueType value, 
           unsigned int index1=0, 
           unsigned int index2=0, 
           unsigned int index3=0)
        {
          if(registerNum >= minMappedAddress_) {

        std::map<unsigned int, unsigned int>::iterator 
          indexIter = addressToIndex_.find(registerNum);

        if(indexIter == addressToIndex_.end()) {
          //          ReportError("Register number " << registerNum 
                  //                  << " not defined");
          return;
        }
        registerNum = indexIter->second;
          }
          setResolved(registerNum, value, index1, index2, index3);
        }
              
      typedef std::map<std::string, unsigned int> StringIntMap; 
                
      void set(std::string xmlTag, valueType value, 
           unsigned int index1=0, unsigned int index2=0, 
           unsigned int index3=0) 
        {
          StringIntMap::iterator tagIter = xmlTagToIndex_.find(xmlTag);
          if(tagIter != xmlTagToIndex_.end()) {
        setResolved(tagIter->second, value, index1, index2, index3);
          }
        }
                
      void set(std::string xmlTag, std::vector<valueType> &values, 
           unsigned int index1=0, unsigned int index2=0)
        {
          StringIntMap::iterator tagIter = xmlTagToIndex_.find(xmlTag);
          if(tagIter != xmlTagToIndex_.end()) {
        for(int index = 0; index < values.size(); index++) {
          setResolved(tagIter->second, values[index], index);
        }
          }
        }

      void set(std::string xmlTag, std::vector<int> &values)
        {
          StringIntMap::iterator tagIter = xmlTagToIndex_.find(xmlTag);
          if(tagIter != xmlTagToIndex_.end()) {
        for(int index = 0; index < values.size(); index++) {
          setResolved(tagIter->second, (valueType)values[index], index);
        }
          }
        }
                  
      void write() 
        {
          std::vector<void*>::iterator 
        bufIter = buffers_.begin();

          std::vector<RegMapBlock*>::iterator 
        regIter = registers_.begin();

          while(regIter != registers_.end()) {
        frame_->writeRegNoLock(*regIter++, static_cast<valueType*>(&(*static_cast< std::vector<valueType>* >(*bufIter++))[0]));
          }

        }   
           
    private:

      RegMapDataFrameManager* frame_;
      unsigned int minMappedAddress_;
      std::map<unsigned int, unsigned int>addressToIndex_;
      StringIntMap xmlTagToIndex_;
      std::vector<RegMapBlock*>registers_;
      std::vector< void* >buffers_;
      unsigned int index1Size_;
      unsigned int index2Size_;
      unsigned int index3Size_;
    }; // RegisterList
        
    template<class dataType> 
      void add(RegisterList<dataType>* registers,
           char* boardName, char* regName, std::string xmlTag, 
           std::string dataType) {

      registers->add(boardName, regName, xmlTag);
      namedRegisters_.push_back(NamedRegister(xmlTag, dataType));
    }       
      
    class NamedRegister {
    public:

      NamedRegister(std::string name, std::string typeName) : 
        name_(name), typeName_(typeName) {};

      std::string name_;
      std::string typeName_;
    };
                                            
    std::vector<NamedRegister> namedRegisters_;

      }; // XMLRegisterMap
    
      protected:
    
      void getRegisters(MuxReadout::MuxXMLFile* xml,
            std::vector<std::string>& containerNames,
            std::string addressVectorName,
            std::string valueVectorName,
            XMLRegisterMap& lookup,
            unsigned int boardNum);
    
    }; // XMLDataFrameManager
      
  } // End namespace receiver
}; // End namespace gcp




#endif // End #ifndef GCP_RECEIVER_XMLDATAFRAMEMANAGER_H