JStatus.hh

Go to the documentation of this file.

#ifndef __JDETECTOR__JSTATUS__
#define __JDETECTOR__JSTATUS__

#include <istream>
#include <ostream>
#include <iomanip>
#include <string>
#include <vector>
#include <map>

#include "JLang/JEquals.hh"
#include "JLang/JType.hh"
#include "JLang/JVectorize.hh"
#include "JLang/JSTDToolkit.hh"
#include "JIO/JSerialisable.hh"
#include "Jeep/JeepToolkit.hh"


/**
 * \author mdejong
 */

namespace JDETECTOR {}
namespace JPP { using namespace JDETECTOR; }

namespace JDETECTOR {

  using JLANG::JType;
  using JLANG::JEquals;
  using JIO::JReader;
  using JIO::JWriter;

 
  /**
   * Auxiliary class for controlling PMT status.
   *
   * The various status are controlled using a bitwise data field.\n
   * The corresponding bits are defined via an internal enumeration.
   */
  struct JStatus :
    public JEquals<JStatus>
  {
    /**
     * Enumeration of status bits.
     *
     * Additional status bits should be included in JGetPMTStatusBit::JGetPMTStatusBit.
     */
    enum JPMTStatusBits_t {
      PMT_DISABLE              =   0,    //!< Enable (disable) use of this PMT if this status bit is 0 (1);
      HIGH_RATE_VETO_DISABLE   =   1,    //!< Enable (disable) use of high-rate veto test if this status bit is 0 (1);
      FIFO_FULL_DISABLE        =   2,    //!< Enable (disable) use of FIFO (almost) full test if this status bit is 0 (1);
      UDP_COUNTER_DISABLE      =   3,    //!< Enable (disable) use of UDP packet counter test if this status bit is 0 (1);
      UDP_TRAILER_DISABLE      =   4     //!< Enable (disable) use of UDP packet trailer test if this status bit is 0 (1);
    };


    /**
     * Default constructor.
     */
    JStatus() :
      status(0)
    {}

  
    /**
     * Constructor.
     *
     * \param  status     status
     */
    JStatus(const int status) :
      status(status)
    {}


    /**
     * Get status.
     *
     * \return            status
     */
    const JStatus& getStatus() const
    { 
      return *this;
    }


    /**
     * Get status.
     *
     * \return            status
     */
    JStatus getStatus()
    { 
      return *this;
    }


    /**
     * Set status.
     *
     * \param  status    status
     */
    void setStatus(const JStatus& status)
    { 
      this->status = status.status;
    }

    
    /**
     * Equal method.
     *
     * \param  status     status
     * \result            true if this status equal to given status; else false
     */
    inline bool equals(const JStatus& status) const
    {
      return this->status == status.status;
    }


    /**
     * Test PMT status.
     *
     * \param  bit        bit
     */
    bool has(const JPMTStatusBits_t bit) const
    {
      return (this->status & (1<<bit)) != 0;
    }


    /**
     * Set PMT status.
     *
     * \param  bit        bit
     */
    void set(const JPMTStatusBits_t bit)
    {
      this->status |= (1<<bit);
    }


    /**
     * Reset PMT status.
     *
     * \param  bit        bit
     */
    void reset(const JPMTStatusBits_t bit)
    {
      this->status &= ~(1<<bit);
    }


    /**
     * Print status.
     *
     * \param  out        output stream
     */
    inline void print(std::ostream& out) const;

    
    /**
     * Read status from input.
     *
     * \param  in         input stream
     * \param  status     status
     * \return            input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JStatus& status)
    {
      return in >> status.status;
    }


    /**
     * Write status to output.
     *
     * \param  out        output stream
     * \param  status     status
     * \return            output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JStatus& status)
    {
      return out << status.status;
    }
  

    /**
     * Read status from input.
     *
     * \param  in         reader
     * \param  status     status
     * \return            reader
     */
    friend inline JReader& operator>>(JReader& in, JStatus& status)
    {
      return in >> status.status;
    }


    /**
     * Write status to output.
     *
     * \param  out        writer
     * \param  status     status
     * \return            writer
     */
    friend inline JWriter& operator<<(JWriter& out, const JStatus& status)
    {
      return out << status.status;
    }       

  protected:
    int status;
  };


  /**
   * Auxiliary class to map key to PMT status bit.
   */
  struct JGetPMTStatusBit :
    public std::map<std::string, JStatus::JPMTStatusBits_t>
  {
    /**
     * Default constructor.
     */
    JGetPMTStatusBit()
    {
      using namespace JPP;

#define MAKE_ENTRY(A) std::make_pair(getClassname(#A), A)

      this->insert(MAKE_ENTRY(JStatus::PMT_DISABLE));
      this->insert(MAKE_ENTRY(JStatus::HIGH_RATE_VETO_DISABLE));
      this->insert(MAKE_ENTRY(JStatus::FIFO_FULL_DISABLE));
      this->insert(MAKE_ENTRY(JStatus::UDP_COUNTER_DISABLE));
      this->insert(MAKE_ENTRY(JStatus::UDP_TRAILER_DISABLE));

#undef MAKE_ENTRY
    }


    /**
     * Get PMT status bit.
     *
     * \param  key         key
     * \return             bit
     */
    JStatus::JPMTStatusBits_t operator()(const std::string& key) const
    {
      return JPP::get_key(*this, key);
    }
  };


  /**
   * Auxiliary class to map PMT status bit to key.
   */
  struct JPutPMTStatusBit :
    public std::map<JStatus::JPMTStatusBits_t, std::string>
  {
    /**
     * Constructor.
     *
     * \param  input       PMT status bits
     */
    JPutPMTStatusBit(const JGetPMTStatusBit& input)
    {
      using namespace std;

      for (JGetPMTStatusBit::const_iterator i = input.begin(); i != input.end(); ++i) {
        this->insert(make_pair(i->second, i->first));
      }
    }


    /**
     * Put PMT status bit.
     *
     * \param  bit        bit
     * \return            bit
     */
    const std::string& operator()(const JStatus::JPMTStatusBits_t bit) const
    {
      return JPP::get_key(*this, bit);
    }
  };


  /**
   * Function object to map key to PMT status bit.
   */
  static const JGetPMTStatusBit getPMTStatusBit;


  /**
   * Function object to map PMT status bit to key.
   */
  static const JPutPMTStatusBit putPMTStatusBit(getPMTStatusBit);


  /**
   * Get PMT status bits.
   *
   * \param  type       type
   * \return            status bits
   */
  inline std::vector<std::string> getPMTStatusBits(const JType<std::string>& type)
  {
    return JPP::make_array(getPMTStatusBit.begin(), getPMTStatusBit.end(), &JGetPMTStatusBit::value_type::first);
  }


  /**
   * Get PMT status bits.
   *
   * \param  type       type
   * \return            status bits
   */
  inline std::vector<JStatus::JPMTStatusBits_t> getPMTStatusBits(const JType<JStatus::JPMTStatusBits_t>& type)
  {
    return JPP::make_array(getPMTStatusBit.begin(), getPMTStatusBit.end(), &JGetPMTStatusBit::value_type::second);
  }


  /**
   * Get PMT status bits.
   *
   * \return            status bits
   */
  template<class T>
  inline std::vector<T> getPMTStatusBits()
  {
    return getPMTStatusBits(JType<T>());
  }


  /**
   * Print PMT status.
   *
   * \param  out        output stream
   */
  inline void JStatus::print(std::ostream& out) const
  {
    using namespace std;

    for (int i = 0; i != sizeof(JStatus) * 8; ++i) {

      try {

        const JPMTStatusBits_t bit = (JPMTStatusBits_t) i;

        out << setw(24) << left << putPMTStatusBit(bit) << right << this->has(bit) << endl;
      }
      catch(const exception&) {}
    }
  }
}

#endif