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 "JDetector/JVersion.hh"
#include "Jeep/JeepToolkit.hh"


/**
 * \file
 *
 * Data structure for detector version.
 * \author mdejong
 */
namespace JDETECTOR {}
namespace JPP { using namespace JDETECTOR; }

namespace JDETECTOR {

  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
      V4 = 4         //!< Version with quaternion and time offset per module
    };

    /**
     * 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));
      this->insert(MAKE_ENTRY(JDetectorVersion::V4));

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


    /**
     * Get index of detector version.
     *
     * \param  variant    variant
     * \return            index
     */
    int operator[](const std::string& variant) const
    {
      using namespace std;
      using namespace JPP;

      const_iterator i = this->find(to_upper(variant));

      if (i != this->end()) 
        return distance(this->begin(), i);
      else
        return -1;
    }


    /**
     * Get index of detector version.
     *
     * \param  version    variant
     * \return            index
     */
    int operator[](const JDetectorVersion& version) const
    {
      return (*this)[version.getVariant()];
    }


    /**
     * Get index of detector version.
     *
     * \param  version    version
     * \return            index
     */
    int operator[](const JDetectorVersion::JVersion_t& version) const
    {
      using namespace std;

      for (const_iterator i = this->begin(); i != this->end(); ++i) {
        if (i->second == version) {
          return distance(this->begin(), i);
        }
      }

      return -1;
    }
  };


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


    /**
     * Get index of detector version.
     *
     * \param  version    version
     * \return            index
     */
    int operator[](const JDetectorVersion::JVersion_t& version) const
    {
      using namespace std;

      const_iterator i = this->find(version);

      if (i != this->end()) 
        return distance(this->begin(), i);
      else
        return -1;
    }
  };


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


  /**
   * Get latest detector version.
   *
   * \param  type       type
   * \return            version
   */
  inline std::string getLatestDetectorVersion(const JType<std::string>& type)
  {
    return putDetectorVersion.rbegin()->second;
  }


  /**
   * Get latest detector version.
   *
   * \param  type       type
   * \return            version
   */
  inline JDetectorVersion::JVersion_t getLatestDetectorVersion(const JType<JDetectorVersion::JVersion_t>& type)
  {
    return putDetectorVersion.rbegin()->first;
  }


  /**
   * Get latest detector version.
   *
   * \return            version
   */
  template<class T>
  inline T getLatestDetectorVersion()
  {
    return getLatestDetectorVersion(JType<T>());
  }
}

#endif