dalImplUtils.h

#ifndef SCT_CONFIGURATION_DALUTILS_H
#define SCT_CONFIGURATION_DALUTILS_H

#include <vector>
#include <config/Configuration.h>

namespace SCTDAL {
  class Barrel;
  class Row;
  class GeographyMUR;

  class Partition;
  class Crate;
  class Rod;
  class RodMUR;
  class Channel;

  class RodRModule;
  class SCT_Module;

  class PowerCard;
  class PowerCrate;
  class PowerChannel;
  class PowerParam;
}

class Log;

class ConfigurationDALImpl;

namespace ConfDALUtils {
  template <typename T> void printVector(std::vector<const T*> objects) {
    typedef std::vector<const T*> TVector;

    if(objects.size() == 0) {
      std::cerr << "Printing empty vector\n";
    }
    for(typename TVector::iterator i = objects.begin(); i != objects.end(); i++) {
      (*i)->print(2, true, std::cerr);
    }
  }

  class Builder {
    ::Configuration &m_conf;
    ConfigurationDALImpl &m_impl;
    Log &log;
  public:
    Builder(::Configuration &conf, ConfigurationDALImpl &impl, Log &log) : m_conf(conf), m_impl(impl), log(log) {}

    // DAQ
    SCTDAL::Partition *getOrCreatePartition(unsigned int partition);
    SCTDAL::Crate *getOrCreateCrate(unsigned int partition, unsigned int crate);
    SCTDAL::Rod *getOrCreateRod(unsigned int partition, unsigned int crate, unsigned int rod);

    // Geog
    SCTDAL::Barrel *getOrCreateBarrel(unsigned int barrel);
    SCTDAL::Row *getOrCreateBarrelRow(unsigned int barrel, unsigned int row);

    // Power
    SCTDAL::PowerCrate *getOrCreatePowerCrate(unsigned int crate);
    SCTDAL::PowerChannel *getOrCreatePowerChannel(unsigned int crate, unsigned int channel);

    // Relative
    SCTDAL::Channel *getOrCreateChannelInRodMur(SCTDAL::RodMUR *murObj, int position);
    SCTDAL::PowerParam *getOrCreatePowerParamInChannel(SCTDAL::PowerChannel *chanObj, std::string state, std::string name);
  };

  class LookUp {
    ::Configuration &m_conf;
    ConfigurationDALImpl &m_impl;
    Log &log;
  public:
    LookUp(::Configuration &conf, ConfigurationDALImpl &impl, Log &log) : m_conf(conf), m_impl(impl), log(log) {}

    const SCTDAL::Partition *getPartition(unsigned int partition);
    const SCTDAL::Crate *getCrate(unsigned int partition, unsigned int crate);
    const SCTDAL::Rod *getRod(unsigned int partition, unsigned int crate, unsigned int rod);
    const SCTDAL::Barrel *getBarrel(unsigned int barrel);
    const SCTDAL::Row *getBarrelRow(unsigned int barrel, unsigned int row);
    const SCTDAL::RodMUR *getMur(unsigned int MUR);
    const SCTDAL::GeographyMUR *getGeogMur(unsigned int MUR);
    const SCTDAL::SCT_Module *getModule(const std::string sn);

    const SCTDAL::PowerCrate *getPowerCrate(unsigned int crate);
    const SCTDAL::PowerChannel *getPowerChannel(unsigned int crate, unsigned int channel);
    const SCTDAL::PowerChannel *getPowerChannelByMUR(unsigned int MUR, unsigned int number);

    const SCTDAL::RodMUR *getMurInRod(const SCTDAL::Rod *rodObj, int position);
    const SCTDAL::Channel *getChannelInRodMur(const SCTDAL::RodMUR *murObj, int position);
    const SCTDAL::RodRModule *getRModuleInRodMur(const SCTDAL::RodMUR *murObj, int position);
    const SCTDAL::PowerParam *getPowerParamInChannel(const SCTDAL::PowerChannel *chanObj, std::string state, std::string name);
    const SCTDAL::PowerCard *getPowerCardInCrate(const SCTDAL::PowerCrate *crate, unsigned int card, std::string type);

    template<class T, class V> bool getSingleBackReference(const T &object, std::string relationship, const V *&relatedObj);

    template<class T> const T *queryViaRelationship(std::string relName, std::string attrName, std::string attrValue);
  };

  template<class T, class V> bool LookUp::getSingleBackReference(const T &object, std::string relationship, const V *&relatedObj) {
    std::vector<const V *> possibleObjs;

    m_conf.referenced_by(object, relationship, possibleObjs);

    if(possibleObjs.size() == 1) {
      relatedObj = possibleObjs.front();
      if(relatedObj == 0) {
    return false;
      } else {
    return true;
      }
    } else {
      return false;
    }
  }

  template<class T> const T *LookUp::queryViaRelationship(std::string relName, std::string attrName, std::string attrValue) {
    std::string query("(this (\"" + relName + "\" some (\"" + attrName + "\" " + attrValue + " =)))");

    std::cerr << "executing query: " << query << std::endl;

    std::vector<const T *> possibles;
    m_conf.template get<T>(possibles, false, true, query);

    const T *queryObj = 0;
    if(possibles.size() == 1) {
      queryObj = possibles.front();
      std::cerr << "Found 1 object:\n";
      //      queryObj->print(2, true, std::cerr);
    } else {
      std::cerr << "Found other objects\n";
      printVector(possibles);
    }

    return queryObj;
  }
}

#endif

---