CSCDQM_Cache.cc

Go to the documentation of this file.

/*
 * =====================================================================================
 *
 *       Filename:  CSCDQM_Cache.cc
 *
 *    Description:  MonitorObject cache implementation
 *
 *        Version:  1.0
 *        Created:  12/01/2008 11:36:11 AM
 *       Revision:  none
 *       Compiler:  gcc
 *
 *         Author:  Valdas Rapsevicius (VR), valdas.rapsevicius@cern.ch
 *        Company:  CERN, CH
 *
 * =====================================================================================
 */

#include "CSCDQM_Cache.h"

namespace cscdqm {

  const bool Cache::get(const HistoDef& histo, MonitorObject*& mo) {
    if (typeid(histo) == EMUHistoDefT) {
      return getEMU(histo.getId(), mo);
    } else if (typeid(histo) == FEDHistoDefT) {
      return getFED(histo.getId(), histo.getFEDId(), mo);
    } else if (typeid(histo) == DDUHistoDefT) {
      return getDDU(histo.getId(), histo.getDDUId(), mo);
    } else if (typeid(histo) == CSCHistoDefT) {
      return getCSC(histo.getId(), histo.getCrateId(), histo.getDMBId(), histo.getAddId(), mo);
    } else if (typeid(histo) == ParHistoDefT) {
      return getPar(histo.getId(), mo);
    }

    return false;
  }

  const bool Cache::getEMU(const HistoId& id, MonitorObject*& mo) {
    if (data[id]) {
      mo = data[id];
      return true;
    }
    return false;
  }

  const bool Cache::getFED(const HistoId& id, const HwId& fedId, MonitorObject*& mo) {
    if (fedPointerValue != fedId) {
      fedPointer = fedData.find(fedId);
      if (fedPointer == fedData.end()) {
        fedPointerValue = 0;
        return false;
      }
      fedPointerValue = fedId;
    }

    if (fedPointer->second[id]) {
      mo = fedPointer->second[id];
      return true;
    }
    return false;
  }

  const bool Cache::getDDU(const HistoId& id, const HwId& dduId, MonitorObject*& mo) {
    if (dduPointerValue != dduId) {
      dduPointer = dduData.find(dduId);
      if (dduPointer == dduData.end()) {
        dduPointerValue = 0;
        return false;
      }
      dduPointerValue = dduId;
    }

    if (dduPointer->second[id]) {
      mo = dduPointer->second[id];
      return true;
    }
    return false;
  }

  const bool Cache::getCSC(
      const HistoId& id, const HwId& crateId, const HwId& dmbId, const HwId& addId, MonitorObject*& mo) {
    if (cscPointer == cscData.end() || cscPointer->crateId != crateId || cscPointer->dmbId != dmbId) {
      cscPointer = cscData.find(boost::make_tuple(crateId, dmbId));
    }

    if (cscPointer != cscData.end()) {
      CSCHistoMapType::const_iterator hit = cscPointer->mos.find(boost::make_tuple(id, addId));
      if (hit != cscPointer->mos.end()) {
        mo = const_cast<MonitorObject*>(hit->mo);
        return true;
      }
    }
    return false;
  }

  const bool Cache::getPar(const HistoId& id, MonitorObject*& mo) {
    if (data[id]) {
      mo = data[id];
      return true;
    }
    return false;
  }

  void Cache::put(const HistoDef& histo, MonitorObject* mo) {
    HistoId id = histo.getId();

    if (typeid(histo) == EMUHistoDefT) {
      data[id] = mo;
    } else

      if (typeid(histo) == FEDHistoDefT) {
        HwId fedId = histo.getFEDId();

        if (fedPointerValue != fedId) {
          fedPointer = fedData.find(fedId);
        }

        if (fedPointer == fedData.end()) {
          MonitorObject** mos = new MonitorObject*[h::namesSize];
          for (unsigned int i = 0; i < h::namesSize; i++)
            mos[i] = nullptr;
          fedPointer = fedData.insert(fedData.end(), std::make_pair(fedId, mos));
        }

        fedPointer->second[id] = mo;
        fedPointerValue = fedId;

      } else

        if (typeid(histo) == DDUHistoDefT) {
          HwId dduId = histo.getDDUId();

          if (dduPointerValue != dduId) {
            dduPointer = dduData.find(dduId);
          }

          if (dduPointer == dduData.end()) {
            MonitorObject** mos = new MonitorObject*[h::namesSize];
            for (unsigned int i = 0; i < h::namesSize; i++)
              mos[i] = nullptr;
            dduPointer = dduData.insert(dduData.end(), std::make_pair(dduId, mos));
          }

          dduPointer->second[id] = mo;
          dduPointerValue = dduId;

        } else

          if (typeid(histo) == CSCHistoDefT) {
            HwId crateId = histo.getCrateId();
            HwId dmbId = histo.getDMBId();
            HwId addId = histo.getAddId();

            CSCHistoKeyType histoKey(id, addId, mo);

            if (cscPointer == cscData.end() || cscPointer->crateId != crateId || cscPointer->dmbId != dmbId) {
              cscPointer = cscData.find(boost::make_tuple(crateId, dmbId));
            }

            if (cscPointer == cscData.end()) {
              CSCKeyType cscKey(crateId, dmbId);
              cscPointer = cscData.insert(cscData.end(), cscKey);
            }
            CSCHistoMapType* mos = const_cast<CSCHistoMapType*>(&cscPointer->mos);
            mos->insert(histoKey);

          } else

            if (typeid(histo) == ParHistoDefT) {
              data[id] = mo;
            }

    if (mo) {
      lookupData.insert(lookupData.end(), LookupKeyType(histo, mo));
    }
  }

  const bool Cache::nextBookedCSC(unsigned int& n, unsigned int& crateId, unsigned int& dmbId) const {
    if (n < cscData.size()) {
      CSCMapType::const_iterator iter = cscData.begin();
      for (unsigned int i = n; i > 0; i--)
        iter++;
      crateId = iter->crateId;
      dmbId = iter->dmbId;
      n++;
      return true;
    }
    return false;
  }

  const bool Cache::nextBookedFED(unsigned int& n, unsigned int& fedId) const {
    if (n < fedData.size()) {
      FEDMapType::const_iterator iter = fedData.begin();
      for (unsigned int i = n; i > 0; i--)
        iter++;
      fedId = iter->first;
      n++;
      return true;
    }
    return false;
  }

  const bool Cache::nextBookedDDU(unsigned int& n, unsigned int& dduId) const {
    if (n < dduData.size()) {
      DDUMapType::const_iterator iter = dduData.begin();
      for (unsigned int i = n; i > 0; i--)
        iter++;
      dduId = iter->first;
      n++;
      return true;
    }
    return false;
  }

  const bool Cache::isBookedCSC(const HwId& crateId, const HwId& dmbId) const {
    CSCMapType::const_iterator it = cscData.find(boost::make_tuple(crateId, dmbId));
    if (it != cscData.end()) {
      return true;
    }
    return false;
  }

  const bool Cache::isBookedFED(const HwId& fedId) const {
    FEDMapType::const_iterator iter = fedData.find(fedId);
    return (iter != fedData.end());
  }

  const bool Cache::isBookedDDU(const HwId& dduId) const {
    DDUMapType::const_iterator iter = dduData.find(dduId);
    return (iter != dduData.end());
  }

}  // namespace cscdqm