utility.cxx

#include <iostream>
#include <string>
#include <sstream>

#include "utility.h"
#include "ConfigurationUtility.h"
#include "primParams.h"

#include "SctApiException.h"

using namespace std;

namespace SctApi {
  namespace Utility {
    void printMemoryBlock(ostream &os, unsigned long *mem, unsigned long words, int wordsPerLine, int level) 
    {
      unsigned int lines = words/wordsPerLine;
      int skipping = 0;

      os.fill('0');

      os << hex;
      for(unsigned int i=0; i<lines; i++) {
        int val = 0;
        for(int j=0; j<wordsPerLine; j++) {
          val+=mem[i*wordsPerLine+j];
        }
        if(val == 0) {
          if(!skipping) 
            os << string("        ", 0, level) << ".";
          skipping++;
        } else {
          if(skipping) os << " Skipped " << dec << skipping << hex << " blank lines\n";
          skipping = 0;

          os << string("        ", 0, level);
          for(int j=0; j<wordsPerLine; j++) {
            os.fill('0');
            os.width(8);
            os << mem[i*wordsPerLine+j] << " ";
          }
          os << endl;
        }
      }
      if(skipping) os << " Skipped " << dec << skipping << hex << " blank lines\n";
      if(lines*wordsPerLine < words) {
        os << string("        ", 0, level);
        for(unsigned int i=lines*wordsPerLine; i<words; i++) {
          os.fill('0');
          os.width(8);
          os << mem[i] << " ";
        }
        os << endl;
      }
      os.fill(' ');

      os << dec;
    }

    UINT32 translateConfigTypeBitset(UINT32 api_bits, bool verbose){
      if (verbose) std::cout << "Translate " << ConfigUtility::apiBitFieldToString(api_bits) << std::endl;
      UINT32 dsp_bits=0;
      for (int bit=1; bit<=SCTAPI_CONFIG_ALL; ++bit){
    if ( 1<<bit & api_bits ) {
      dsp_bits |= translateConfigType(ConfigType(bit));
      if (verbose) {
        std::cout << " API bit " << bit << " set ==> or with 0x" 
              << hex << translateConfigType(ConfigType(bit))
              << " to get 0x" << dsp_bits << dec << std::endl;
      }
    }
      }
      return dsp_bits;
    }

    UINT32 getSetableConfigType(UINT32 bits, bool verbose){
      switch (bits){
      case CONFIG_MODULE_CFG:
      case CONFIG_MODULE_CALDATA:      
      case CONFIG_MODULE_BASIC:
      case CONFIG_MODULE_TRIM:
      case CONFIG_MODULE_ALL:
    return bits;
      default:
    if (bits<64){
      std::cout << "Sending whole config instead of 0x" << hex << bits << dec << std::endl;
      return CONFIG_MODULE_ALL;
    }else{
      std::cerr << "WARNING - unknown cfg type bits 0x" 
            << std::hex << bits << std::dec << std::endl;
      return CONFIG_MODULE_ALL;   
    }
      }
    }

unsigned translateConfigTypeForSendPrimitive(ConfigType cfg){
  unsigned realConfig=CONFIG_MODULE_ALL;
  switch (cfg){
  case SCTAPI_CONFIG_TRIM:
    realConfig = CONFIG_MODULE_TRIM; break;
  case SCTAPI_CONFIG_BASIC:
  case SCTAPI_CONFIG_CFG:
    realConfig = CONFIG_MODULE_BASIC; break;
  default:
    realConfig = CONFIG_MODULE_ALL; break;
  }
  return realConfig;
}


    unsigned translateConfigType(ConfigType cfg){
      unsigned realtype;
      switch (cfg){
      case SCTAPI_CONFIG_NONE: {
#ifndef CONFIG_MODULE_CFG
    std::ostringstream oss;
    oss << "Invalid config specification : " << (int)cfg;
    throw SctApiException(oss.str());
#endif
    realtype=0;
    break;
      }
      case SCTAPI_CONFIG_CFG:
    realtype=CONFIG_MODULE_CFG;
    break;
      case SCTAPI_CONFIG_BASIC:
    realtype=CONFIG_MODULE_BASIC;
    break;
      case SCTAPI_CONFIG_TRIM:
    realtype=CONFIG_MODULE_TRIM;
    break;
      case SCTAPI_CONFIG_MASK:
      case SCTAPI_CONFIG_OTHER:
      case SCTAPI_CONFIG_ALL:
    realtype=CONFIG_MODULE_ALL;
    break;
      default:
    std::cout << "translateConfigType: Invalid type specification " << cfg << endl;
    throw SctApiException("Invalid config specification");
    break;
      }
      return realtype;
    }

    UINT32 translateApiBanksToRodCfgBitSet(std::list<BankType> banks){
      UINT32 bits=0;
      for (std::list<BankType>::const_iterator i = banks.begin(); i!=banks.end(); ++i){
    bits |= 1<< translateBank(*i);
      }
      return bits;
    }

    unsigned translateChip(unsigned chip) {
      if (chip<6) {
    return chip;
      } else if (chip<12) {
    return chip+2;
      } else{
    return ALL_CHIPS;
      }
    }

    int translateBank(BankType bank) {
      int realBank;
      switch(bank) {
      case SCTAPI_BANK_PHYSICS:
        realBank = PHYSICS_CONFIG_SET;
        break;
      case SCTAPI_BANK_SCAN:
        realBank = SCAN_CONFIG_SET;
        break;
      case SCTAPI_BANK_CALIBRATION:
        realBank = SPARE_CONFIG_SET;
        break;
      default:
        std::cout << "translateBank: Invalid bank specification " << bank << endl;
        throw SctApiException("Invalid bank specification");
      }
      return realBank;
    }
  }
}

---