JDBToolkit.hh

Go to the documentation of this file.

#ifndef __JDB_JDBTOOLKIT__
#define __JDB_JDBTOOLKIT__

#include <string>
#include <map>

#include "JLang/JException.hh"

#include "JDB/JDB.hh"
#include "JDB/JDetectors.hh"
#include "JDB/JCLBID.hh"
#include "JDB/JUPI.hh"
#include "JDB/JUPI_t.hh"
#include "JDB/JSelector.hh"
#include "JDB/JSelectorSupportkit.hh"


/**
 * \author mdejong
 */

namespace JDATABASE {};
namespace JPP { using namespace JDATABASE; }

/**
 * Auxiliary classes and methods for database I/O.
 */
namespace JDATABASE {

  using JLANG::JValueOutOfRange;
  using JLANG::JDatabaseException;


  /**
   * Auxiliary class for mapping serial number and object identifier of detectors.
   */
  struct JDetectorsHelper {
    /**
     * Initialise.
     */
    void initialise()
    {
      ResultSet& rs  = JDB::get()->StreamDS(getTable<JDetectors>(), JSelector());

      for (JDetectors parameters; rs >> parameters; ) {
        det2id[parameters.OID] = parameters.SERIALNUMBER;
        id2det[parameters.SERIALNUMBER] = parameters.OID;
      }
  
      rs.Close();
    }


    /**
     * Get detector serial number.
     *
     * \param  detid                 object identifier
     * \return                       serial number
     */
    int operator()(const std::string& detid)
    {
      std::map<std::string, int>::const_iterator p = det2id.find(detid);

      if (p == det2id.end()) {

        initialise();

        p = det2id.find(detid);

        if (p == det2id.end()) {
          THROW(JDatabaseException, "Invalid detector identifier " << detid);
        }
      }
        
      return p->second;
    }


    /**
     * Get detector identifier.
     *
     * \param  id                    serial number
     * \return                       object identifier
     */
    inline std::string operator()(const int id)
    {
      std::map<int, std::string>::const_iterator p = id2det.find(id);

      if (p == id2det.end()) {

        initialise();

        p = id2det.find(id);

        if (p == id2det.end()) {
          THROW(JDatabaseException, "Invalid detector identifier " << id);
        }
      }

      return p->second;
    }

  protected:
    std::map<int, std::string> id2det;
    std::map<std::string, int> det2id;
  };


  /**
   * Auxiliary class for mapping UPI of central-logic board to module identifier.
   */
  struct JCLBIDHelper {
    /**
     * Initialise.
     */
    void initialise()
    {
      ResultSet& rs  = JDB::get()->StreamDS(getTable<JCLBID>(), getSelector<JCLBID>());
  
      for (JCLBID parameters; rs >> parameters; ) {
        upi2id[parameters.CLBUPI] = parameters.CLBID;
        id2upi[parameters.CLBID] = parameters.CLBUPI;
      }
  
      rs.Close();
    }


    /**
     * Get module identifier.
     *
     * \param  upi                   %UPI
     * \return                       module identifier
     */
    int operator()(const JUPI_t& upi)
    {
      std::map<JUPI_t, int>::const_iterator p = upi2id.find(upi);

      if (p == upi2id.end()) {
        
        initialise();

        p = upi2id.find(upi);

        if (p == upi2id.end()) {
          THROW(JDatabaseException, "Invalid UPI " << upi);
        }
      }

      return p->second;
    }


    /**
     * Get %UPI.
     *
     * \param  id                    module identifier
     * \return                       %UPI
     */
    JUPI_t operator()(const int id)
    {
      std::map<int, JUPI_t>::const_iterator p = id2upi.find(id);

      if (p == id2upi.end()) {
        
        initialise();

        p = id2upi.find(id);

        if (p == id2upi.end()) {
          THROW(JDatabaseException, "Invalid module identifier " << id);
        }
      }

      return p->second;
    }

  protected:
    std::map<JUPI_t, int> upi2id;
    std::map<int, JUPI_t> id2upi;
  };


  /**
   * Auxiliary class for mapping %UPI of product to serial number.
   */
  struct JUPIHelper {
    /**
     * Initialise.
     *
     * \param  pbs                   %PBS
     */
    void initialise(const JPBS_t& pbs)
    {
      ResultSet& rs  = JDB::get()->StreamDS(getTable<JUPI>(), getSelector<JUPI>(pbs));

      for (JUPI parameters; rs >> parameters; ) {

        const JUPI_t upi(parameters.PBS,
                         parameters.VARIANT,
                         parameters.VERSION,
                         parameters.SERIALNUMBER);
        
        number2upi[pbs][parameters.SERIALNUMBER] = upi;
      }

      rs.Close();
    }


    /**
     * Get %UPI.
     *
     * \param  pbs                   %PBS
     * \param  number                serial number
     * \return                       %UPI
     */
    JUPI_t operator()(const JPBS_t& pbs, const int number)
    {
      using namespace std;
      using namespace JPP;
      
      map<JPBS_t, map<int, JUPI_t>>::const_iterator p = number2upi.find(pbs);

      if (p == number2upi.end()) {
        
        initialise(pbs);
        p = number2upi.find(pbs);
      }

      if (p != number2upi.end()) {

        map<int, JUPI_t>::const_iterator q = p->second.find(number);

        if (q != p->second.end()) {
          
          return q->second;
          
        } else {
          
          THROW(JValueOutOfRange, "Invalid serial number " << number);    
        }
        
      } else {
        
        THROW(JDatabaseException, "Invalid PBS " << pbs);
      }
    }

  protected:
    std::map<JPBS_t, std::map<int, JUPI_t> > number2upi;
  };

  
  /**
   * Wrapper data structure for initialisation of fuction objects.
   *
   * The fuction objects will expand on the fly making a corresponding query to the database.\n
   * To avoid making a query within another query, a given function object can <em>a priori</em> 
   * be initialised using the static method JDBToolkit::initialise.
   */
  struct JDBToolkit {
    /**
     * Initialise.
     *
     * \param  helper                database helper
     * \param  args                  values
     */
    template<class JHelper_t, class ...Args>
    static void initialise(JHelper_t& helper, const Args& ...args)
    {
      helper.initialise(args...);
    }
  };


  extern JDetectorsHelper getDetector;           //!< Function object for mapping serial number to object identifier of detector and vice versa.
  extern JCLBIDHelper     getCLBID;              //!< Function object for mapping %UPI of central-logic board to module identifier.
  static JCLBIDHelper&    getCLBUPI = getCLBID;  //!< Function object for mapping module identifier to %UPI of central-logic board.
  extern JUPIHelper       getUPI;                //!< Function object for mapping %PBS and serial number to %UPI.
}

#endif