JSelectorSupportkit.hh

Go to the documentation of this file.

#ifndef __JDB_JSELECTORSUPPORTKIT__
#define __JDB_JSELECTORSUPPORTKIT__

#include <string>

#include "JLang/JConversion.hh"

#include "JDB/JDBString.hh"
#include "JDB/JSelector.hh"
#include "JDB/JPBS_t.hh"
#include "JDB/JDBTypes.hh"


/**
 * \author mdejong
 */

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

namespace JDATABASE {

  namespace APIV2 {}

  using JLANG::JConversion;

  /**
   * Template definition for getting table specific selector.\n
   * Note that the template argument
   * <tt>T</tt> refers to the targeted table and
   * <tt>JTable_t</tt> to the actual table.\n
   * This allows to use pointers to data members for column names rather than text strings.
   */
  template<class T, class JTable_t = T, bool is_same = JConversion<T, JTable_t>::is_same>
  struct getSelector;

  /**
   * Template specialisation for getting table specific selector.
   */
  template<class T>
  struct getSelector<T, JPersons, true> :
    public JSelector
  {
    /**
     * Get selector for the given table based on the location identifier.
     *
     * \param  locID           location identifier
     */
    getSelector(const JDBString& locID)
    {
      this->add(&T::LOCATIONID, locID);
    }

    /**
     * Get selector for the given table based on the login name.
     *
     * \param  login              login string
     */
    getSelector(const std::string& login)
    {
      this->add(&T::LOGIN, login);
    }
  };


  /**
   * Template specialisation for getting table specific selector.
   */
  template<class T>
  struct getSelector<T, JDetectors, true> :
    public JSelector
  {
    /**
     * Get selector for the given table based on the serial number.
     *
     * \param  id              serial number
     */
    getSelector(const int id)
    {
      this->add(&T::SERIALNUMBER, id);
    }


    /**
     * Get selector for the given table based on the object identifier.
     *
     * \param  detid           detector identifier
     */
    getSelector(const std::string& detid)
    {
      this->add(&T::OID, detid);
    }
  };


  /**
   * Template specialisation for getting table specific selector.
   */
  template<class T>
  struct getSelector<T, JRuns, true> :
    public JSelector
  {
    /**
     * Get selector for the given table based on the detector serial number.
     *
     * \param  id              detector serial number
     */
    getSelector(const int id)
    {
      this->add(&T::DETID, id);
    }


    /**
     * Get selector for the given table based on the detector serial number and run number.
     *
     * \param  id              detector serial number
     * \param  run             run number
     */
    getSelector(const int id,
                const int run)
    {
      this->add(&T::DETID, id);
      this->add(&T::RUN,   run);
    }


    /**
     * Get selector for the given table based on the detector serial number and run number.
     *
     * \param  id              detector serial number
     * \param  minrun          minimal run number
     * \param  maxrun          maximal run number
     */
    getSelector(const int id,
                const int minrun,
                const int maxrun)
    {
      this->add(&T::DETID, id);
      this->add(&T::RUN,   minrun, Selector::RelOp::GreaterEqual);
      this->add(&T::RUN,   maxrun, Selector::RelOp::LessEqual);
    }
  };


  /**
   * Template specialisation for getting table specific selector.
   */
  template<class T>
  struct getSelector<T, JDatalogNumbers, true> :
    public JSelector
  {
    /**
     * Get selector for the given table based on the detector identifier and a run range.
     *
     * \param  detid           detector identifier
     * \param  minrun          minimal run number
     * \param  maxrun          maximal run number
     */
    getSelector(const std::string& detid,
                const int          minrun,
                const int          maxrun)
    {
      this->add(&T::DETID, detid);
      this->add("MINRUN",  minrun);
      this->add("MAXRUN",  maxrun);
    }
  };


  /**
   * Template specialisation for getting table specific selector.
   */
  template<class T>
  struct getSelector<T, JAllParams, true> :
    public JSelector
  {
    /**
     * Get selector for the given table based on the sub-system identifier.
     *
     * \param  ssid            ssid
     */
    getSelector(const std::string& ssid)
    {
      this->add(&T::SUBSYSTEMID, ssid);
    }
  };


  /**
   * Template specialisation for getting table specific selector.
   */
  template<class T>
  struct getSelector<T, JToAshort, true> :
    public JSelector
  {
    /**
     * Get selector for the given table based on the detector identifier and a run range.
     *
     * \param  detid           detector identifier
     * \param  minrun          minimal run number
     * \param  maxrun          maximal run number
     */
    getSelector(const std::string& detid,
                const int          minrun,
                const int          maxrun)
    {
      this->add(&T::DETID, detid);
      this->add("MINRUN",  minrun);
      this->add("MAXRUN",  maxrun);
    }
  };


  /**
   * Template specialisation for getting table specific selector.
   */
  template<class T>
  struct getSelector<T, JCLBMap, true> :
    public JSelector
  {
    /**
     * Get selector for the given table based on the detector identifier.
     *
     * \param  detoid          detector identifier
     */
    getSelector(const std::string& detoid)
    {
      this->add(&T::DETOID, detoid);
    }
  };


  /**
   * Template specialisation for getting table specific selector.
   */
  template<class T>
  struct getSelector<T, JDetectorIntegration, true> :
    public JSelector
  {
    /**
     * Get selector for the given table based on the serial number.
     *
     * \param  id              serial number
     */
    getSelector(const int id)
    {
      this->add(&T::DETID, id);
    }


    /**
     * Get selector for the given table based on the detector identifier and a run range.
     *
     * \param  detoid          detector identifier
     */
    getSelector(const std::string& detoid)
    {
      this->add(&T::DETOID, detoid);
    }
  };


  /**
   * Template specialisation for getting table specific selector.
   */
  template<class T>
  struct getSelector<T, JRunSummaryNumbers, true> :
    public JSelector
  {
    /**
     * Get selector for the given table based on the detector identifier and a run range.
     *
     * \param  detid           detector identifier
     * \param  minrun          minimal run number
     * \param  maxrun          maximal run number
     */
    getSelector(const std::string& detid,
                const int          minrun,
                const int          maxrun)
    {
      this->add(&T::DETID, detid);
      this->add("MINRUN",  minrun);
      this->add("MAXRUN",  maxrun);
    }
  };


  /**
   * Template specialisation for getting table specific selector.
   */
  template<class T>
  struct getSelector<T, JRunQuality, true> :
    public getSelector<JRunSummaryNumbers>
  {
    /**
     * Get selector for the given table based on the detector identifier and a run range.
     *
     * \param  detid           detector identifier
     * \param  minrun          minimal run number
     * \param  maxrun          maximal run number
     */
    getSelector(const std::string& detid,
                const int          minrun,
                const int          maxrun) :
      getSelector<JRunSummaryNumbers>(detid, minrun, maxrun)
    {}
  };


  /**
   * Template specialisation for getting table specific selector.
   */
  template<class T>
  struct getSelector<T, JRunsetupParams, true> :
    public JSelector
  {
    /**
     * Get selector for the given table based on the detector and run-setup identifier.
     *
     * \param  detid           detector identifier
     * \param  rs_oid          runsetup identifier
     */
    getSelector(const std::string& detid,
                const std::string& rs_oid)
    {
      this->add(&T::DETID,  detid);
      this->add(&T::RS_OID, rs_oid);
    }
  };


  /**
   * Template specialisation for getting table specific selector.
   */
  template<class T>
  struct getSelector<T, JPMTHVSettings, true> :
    public JSelector
  {
    /**
     * Get selector for the given table based on the detector and run number.
     *
     * \param  detoid          detector identifier
     * \param  cg_name         cg_name
     */
    getSelector(const std::string& detoid,
                const std::string& cg_name)
    {
      this->add(&T::DETOID,  detoid);
      this->add(&T::CG_NAME, cg_name);
    }
  };


  /**
   * Template specialisation for getting table specific selector.
   */
  template<class T>
  struct getSelector<T, JPMTHVRunSettings, true> :
    public JSelector
  {
    /**
     * Get selector for the given table based on the detector and run number.
     *
     * \param  id              detector identifier
     * \param  run             run number
     */
    getSelector(const int id,
                const int run)
    {
      this->add(&T::DETID, id);
      this->add(&T::RUN,   run);
    }

    /**
     * Get selector for the given table based on the detector and run number.
     *
     * \param  detoid          detector identifier
     * \param  run             run number
     */
    getSelector(const std::string& detoid,
                const int          run)
    {
      this->add(&T::DETOID, detoid);
      this->add(&T::RUN,    run);
    }
  };


  /**
   * Template specialisation for getting table specific selector.
   */
  template<class T>
  struct getSelector<T, JVendorHV, true> :
    public JSelector
  {
    /**
     * Get selector for the given table based on the detector identifier.
     *
     * \param  detid           detector identifier
     */
    getSelector(const int detid)
    {
      this->add(&T::DETID, detid);
    }
  };


  /**
   * Template specialisation for getting table specific selector.
   */
  template<class T>
  struct getSelector<T, JCLBID, true> :
    public JSelector
  {
    /**
     * Get selector for the given table.
     */
    getSelector()
    {
      this->add(&T::CLBID, -1, Selector::RelOp::Different);
    }
  };  


  /**
   * Template specialisation for getting table specific selector.
   */
  template<class T>
  struct getSelector<T, JUPI, true> :
    public JSelector
  {
    /**
     * Get selector for the given table based on the detector identifier.
     *
     * \param  pbs             %PBS
     */
    getSelector(const JPBS_t pbs)
    {
      this->add(&T::PBS, pbs);
    }
  };  


  /**
   * Template specialisation for getting table specific selector.
   */
  template<class T>
  struct getSelector<T, JAHRS, true> :
    public JSelector
  {
    /**
     * Get selector for the given table based on the detector identifier and a run range.
     *
     * \param  detid           detector identifier
     * \param  minrun          minimal run number
     * \param  maxrun          maximal run number
     */
    getSelector(const int detid,
                const int minrun,
                const int maxrun)
    {
      this->add(&T::DETID, detid);
      this->add("MINRUN",  minrun);
      this->add("MAXRUN",  maxrun);
    }
  };


  /**
   * Template specialisation for getting table specific selector.
   */
  template<class T>
  struct getSelector<T, JAHRSDetectorCalibration, true> :
    public JSelector
  {
    /**
     * Get selector for the given table based on the detector and run number.
     *
     * \param  detoid          detector identifier
     */
    getSelector(const std::string& detoid)
    {
      this->add(&T::DETOID, detoid);
    }
  };


  /**
   * Template specialisation for getting table specific selector.
   */
  template<class T>
  struct getSelector<T, JDetCalibrations, true> :
    public JSelector
  {
    /**
     * Get selector for the given table based on the detector and run number.
     *
     * \param  detoid          detector identifier
     */
    getSelector(const std::string& detoid)
    {
      this->add(&T::DETOID, detoid);
    }
  };


  /**
   * Template specialisation for getting table specific selector.
   */
  template<class T>
  struct getSelector<T, APIV2::JCalibration_t, true> :
    public JSelector
  {
    /**
     * Get selector for the given table based on the detector and run number.
     *
     * \param  detoid          detector identifier 
     * \param  operation       operation identifier
     */
    getSelector(const std::string& detoid,
                const std::string& operation)
    {
      this->add(&T::DetOID,      detoid);
      this->add(&T::OperationId, operation);
    }
  };


  /**
   * Template specialisation for getting table specific selector.
   */
  template<class T>
  struct getSelector<T, APIV2::JRunCalibration, true> :
    public JSelector
  {
    /**
     * Get selector for the given table based on the detector and run number.
     *
     * \param  detoid          detector identifier
     * \param  run             run number
     */
    getSelector(const std::string& detoid,
                const int          run)
    {
      this->add(&T::DetOID,     detoid);
      this->add(&T::Run,        run);
    }

    /**
     * Get selector for the given table based on the detector and run number.
     *
     * \param  detoid          detector identifier
     * \param  run             run number
     * \param  ranking         ranking
     */
    getSelector(const std::string& detoid,
                const int          run,
                const int          ranking)
    {
      this->add(&T::DetOID,     detoid);
      this->add(&T::Run,        run);
      this->add(&T::Ranking,    ranking);
    }
  };
}

#endif