JDBToolkit.hh

Go to the documentation of this file.

#ifndef __JDB_JDBTOOLKIT__
#define __JDB_JDBTOOLKIT__

#include <string>
#include <map>

#include "JLang/JException.hh"
#include "JLang/JLangToolkit.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;
  using JLANG::JType;


  /**
   * 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;
    }


    /**
     * Get serial number according given data type.
     *
     * \param  detid                 object identifier or serial number
     * \param  type                  data type
     * \return                       object identifier
     */
    int operator()(const std::string& detid, const JType<int>& type)
    {
      using namespace JPP;

      if (is_integer(detid))
        return to_value<int>(detid);
      else
        return (*this)(detid);
    }


    /**
     * Get detector identifier according given data type.
     *
     * \param  detid                 object identifier or serial number
     * \param  type                  data type
     * \return                       object identifier
     */
    std::string operator()(const std::string& detid, const JType<std::string>& type)
    {
      using namespace JPP;

      if (is_integer(detid))
        return (*this)(to_value<int>(detid));
      else
        return detid;
    }


    /**
     * Helper object.
     */
    static JDetectorsHelper helper;

  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;
    }


    /**
     * Helper object.
     */
     static JCLBIDHelper helper;

  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);
      }
    }


    /**
     * Helper object.
     */
    static JUPIHelper helper;


  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                helper object
     * \param  args                  values
     */
    template<class JHelper_t, class ...Args>
    static void initialise(JHelper_t& helper, const Args& ...args)
    {
      helper.initialise(args...);
    }


    /**
     * Initialise.
     *
     * \param  pF                    helper function
     * \param  args                  values
     */
    template<class ...Args>
    static void initialise(JDetectorsHelper& (*pF)(), const Args& ...args)
    {
      JDetectorsHelper::helper.initialise(args...);
    }


    /**
     * Initialise.
     *
     * \param  pF                    helper function
     * \param  args                  values
     */
    template<class JHelper_t, class ...Args>
    static void initialise(JHelper_t& (*pF)(), const Args& ...args)
    {
      JHelper_t::helper.initialise(args...);
    }
  };


  /**
   * Auxiliary function for helper object initialisation.
   *
   * \return                       helper object
   */
  inline JDetectorsHelper& getDetector()
  {
    return JDetectorsHelper::helper;
  }


  /**
   * Get detector identifier or serial number, depending on template data type.
   *
   * \param  detid                 object identifier or serial number
   * \return                       object identifier or serial number
   */
  template<class T>
  inline T getDetector(const std::string& detid)
  {
    return JDetectorsHelper::helper(detid, JType<T>());
  }

  
  /**
   * Get detector serial number.
   *
   * \param  detid                 object identifier
   * \return                       serial number
   */
  inline int getDetector(const std::string& detid)
  {
    return JDetectorsHelper::helper(detid);
  }
  

  /**
   * Get detector identifier.
   *
   * \param  id                    serial number
   * \return                       object identifier
   */
  inline std::string getDetector(const int id)
  {
    return JDetectorsHelper::helper(id);
  }


  /**
   * Auxiliary function for helper object initialisation.
   *
   * \return                        helper
   */
  inline JCLBIDHelper& getCLBID()
  {
    return JCLBIDHelper::helper;
  }


  /**
   * Get module identifier.
   *
   * \param  upi                   %UPI
   * \return                       module identifier
   */
  inline int getCLBID(const JUPI_t& upi)
  {
    return JCLBIDHelper::helper(upi);
  }


  /**
   * Auxiliary function for helper object initialisation.
   *
   * \return                        helper
   */
  inline JCLBIDHelper& getCLBUPI()
  {
    return JCLBIDHelper::helper;
  }


  /**
   * Get %UPI.
   *
   * \param  id                    module identifier
   * \return                       %UPI
   */
  inline JUPI_t getCLBUPI(const int id)
  {
    return JCLBIDHelper::helper(id);
  }


  /**
   * Auxiliary function for helper object initialisation.
   *
   * \return                        helper
   */
  inline JUPIHelper& getUPI()
  {
    return JUPIHelper::helper;
  }


  /**
   * Get %UPI.
   *
   * \param  pbs                   %PBS
   * \param  number                serial number
   * \return                       %UPI
   */
  inline JUPI_t getUPI(const JPBS_t& pbs, const int number)
  {
    return JUPIHelper::helper(pbs, number);
  }
}

#endif