JDetectorVersion.hh

Go to the documentation of this file.

#ifndef __JDETECTOR__JDETECTORVERSION__
#define __JDETECTOR__JDETECTORVERSION__
 
#include <string>
#include <vector>
#include <map>
 
#include "JLang/JType.hh"
#include "JLang/JLangToolkit.hh"
#include "JLang/JException.hh"
#include "JLang/JVectorize.hh"
#include "Jeep/JVersion.hh"
#include "Jeep/JeepToolkit.hh"
 
 
/**
 * \file
 *
 * Data structure for detector version.
 * \author mdejong
 */
namespace JDETECTOR {}
namespace JPP { using namespace JDETECTOR; }
 
namespace JDETECTOR {
 
  using JEEP::JVersion;
  using JLANG::JType;
  using JLANG::JTypeInformationException;
 
 
  /**
   * Detector version.
   */
  struct JDetectorVersion : 
    public JVersion
  {
    /**
     * Enumeration of version types.\n
     * Additional version types should be included in JGetDetectorVersion::JGetDetectorVersion.
     */
    enum JVersion_t {
      V1 = 1,        //!< First version
      V2 = 2,        //!< Version with UTC time and UTM position data
      V3 = 3         //!< Version with PMT status field and comments
    };
 
    /**
     * Default constructor.
     */
    JDetectorVersion() :
      JVersion()
    {}
 
 
    /**
     * Constructor.
     *
     * \param  version    version
     */
    JDetectorVersion(const JVersion& version) :
      JVersion(version)
    {}
  };
 
 
  /**
   * Auxiliary class to map detector variant to detector version.
   */
  struct JGetDetectorVersion :
    public std::map<std::string, JDetectorVersion::JVersion_t>
  {
    /**
     * Default constructor.
     */
    JGetDetectorVersion()
    {
      using namespace JPP;
 
#define MAKE_ENTRY(A) std::make_pair(to_upper(getClassname(#A)), A)
 
      this->insert(MAKE_ENTRY(JDetectorVersion::V1));
      this->insert(MAKE_ENTRY(JDetectorVersion::V2));
      this->insert(MAKE_ENTRY(JDetectorVersion::V3));
 
#undef MAKE_ENTRY
    }
 
 
    /**
     * Get detector version.
     *
     * \param  variant    variant
     * \return            version
     */
    JDetectorVersion::JVersion_t operator()(const std::string& variant) const
    {
      using namespace JPP;
 
      const_iterator i = this->find(to_upper(variant));
 
      if (i != this->end()) {
        return i->second;
      } else {
        THROW(JTypeInformationException, "Invalid variant <" << variant << ">");
      }
    }
 
 
    /**
     * Get detector version.
     *
     * \param  version    version
     * \return            version
     */
    JDetectorVersion::JVersion_t operator()(const JDetectorVersion& version) const
    {
      return (*this)(version.getVariant());
    }
  };
 
 
  /**
   * Auxiliary class to map detector version to detector variant. 
   */
  struct JPutDetectorVersion :
    public std::map<JDetectorVersion::JVersion_t, std::string>
  {
    /**
     * Constructor.
     *
     * \param  input      detector versions
     */
    JPutDetectorVersion(const JGetDetectorVersion& input)
    {
      using namespace std;
 
      for (JGetDetectorVersion::const_iterator i = input.begin(); i != input.end(); ++i) {
        this->insert(make_pair(i->second, i->first));
      }
    }
 
 
    /**
     * Put detector version.
     *
     * \param  version    version
     * \return            version
     */
    const std::string& operator()(const JDetectorVersion::JVersion_t& version) const
    {
      const_iterator i = this->find(version);
 
      if (i != this->end()) {
        return i->second;
      } else {
        THROW(JTypeInformationException, "Invalid version <" << version << ">");
      }
    }
  };
 
 
  /**
   * Function object to map detector variant to detector version.
   */
  static const JGetDetectorVersion getDetectorVersion;
 
 
  /**
   * Function object to map detector version to detector variant. 
   */
  static const JPutDetectorVersion putDetectorVersion(getDetectorVersion);
 
 
  /**
   * Get detector versions.
   *
   * Note that the order of the versions is descending.
   *
   * \param  type       type
   * \return            versions
   */
  inline std::vector<std::string> getDetectorVersions(const JType<std::string>& type)
  {
    return JLANG::make_array(putDetectorVersion.rbegin(), putDetectorVersion.rend(), &JPutDetectorVersion::value_type::second);
  }
 
 
  /**
   * Get detector versions.
   *
   * Note that the order of the versions is descending.
   *
   * \param  type       type
   * \return            versions
   */
  inline std::vector<JDetectorVersion::JVersion_t> getDetectorVersions(const JType<JDetectorVersion::JVersion_t>& type)
  {
    return JLANG::make_array(putDetectorVersion.rbegin(), putDetectorVersion.rend(), &JPutDetectorVersion::value_type::first);
  }
 
 
  /**
   * Get detector versions.
   *
   * \return            versions
   */
  template<class T>
  inline std::vector<T> getDetectorVersions()
  {
    return getDetectorVersions(JType<T>());
  }
}
 
#endif