JStatus.hh

Go to the documentation of this file.

#ifndef __JLANG__JSTATUS__
#define __JLANG__JSTATUS__
 
#include <istream>
#include <ostream>
#include <iomanip>
#include <string>
#include <map>
 
#include "JLang/JEquals.hh"
#include "JLang/JType.hh"
 
 
/**
 * \author mdejong
 */
 
namespace JLANG {}
namespace JPP { using namespace JLANG; }
 
namespace JLANG {
 
  /**
   * Auxiliary class for handling status.
   *
   * The various status are controlled using a bitwise data field.\n
   * The corresponding bits can externally be defined (e.g.\ via an enumeration).
   */
  struct JStatus :
    public JEquals<JStatus>
  {
    typedef int  status_type;
 
    static const int NUMBER_OF_STATUS_BITS  =  sizeof(status_type) * 8;    //!< number of status bits
 
 
    /**
     * Default constructor.
     */
    JStatus() :
      status(0)
    {}
 
  
    /**
     * Constructor.
     *
     * \param  status     status
     */
    JStatus(const status_type status) :
      status(status)
    {}
 
 
    /**
     * Get status.
     *
     * \return            status
     */
    status_type getStatus(const JType<status_type>& type) const
    { 
      return this->status;
    }
 
 
    /**
     * Get status.
     *
     * \return            status
     */
    JStatus getStatus(const JType<JStatus>& type) const
    { 
      return *this;
    }
 
 
    /**
     * Get status.
     *
     * \return            status
     */
    template<class T>
    const T getStatus() const
    { 
      return getStatus(JType<T>());
    }
 
 
    /**
     * Get status.
     *
     * \return            status
     */
    const JStatus& getStatus() const
    { 
      return static_cast<const JStatus&>(*this);
    }
 
 
    /**
     * Get status.
     *
     * \return            status
     */
    status_type& getStatus(const JType<status_type>& type)
    { 
      return this->status;
    }
 
 
    /**
     * Get status.
     *
     * \return            status
     */
    JStatus& getStatus(const JType<JStatus>& type)
    { 
      return *this;
    }
 
 
    /**
     * Get status.
     *
     * \return            status
     */
    template<class T>
    T& getStatus()
    {
      return getStatus(JType<T>());
    }
 
 
    /**
     * Get status.
     *
     * \return            status
     */
    JStatus& getStatus()
    { 
      return static_cast<JStatus&>(*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;
    }
 
 
    /**
     * Get combined status.
     *
     * \param  status     status
     * \return            status
     */
    JStatus getAND(const JStatus& status) const
    { 
      return JStatus(this->status & status.status);
    }
 
 
    /**
     * Get combined status.
     *
     * \param  status     status
     * \return            status
     */
    JStatus getOR(const JStatus& status) const
    { 
      return JStatus(this->status | status.status);
    }
 
 
    /**
     * Test PMT status.
     *
     * \param  bit        bit
     * \return            true if bit is set; else false
     */
    bool has(const int bit) const
    {
      return (this->status & (1<<bit)) != 0;
    }
 
 
    /**
     * Set PMT status.
     *
     * \param  bit        bit
     */
    void set(const int bit)
    {
      this->status |= (1<<bit);
    }
 
 
    /**
     * Reset PMT status.
     *
     * \param  bit        bit
     */
    void reset(const int bit)
    {
      this->status &= ~(1<<bit);
    }
 
    
    /**
     * 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;
    }
 
  protected:
    status_type status;
  };
 
 
  /**
   * Auxiliary class to map key to status bit.
   */
  struct JGetStatusBit :
    public std::map<std::string, int>
  {
    /**
     * Get status bit.
     *
     * \param  key         key
     * \return             bit
     */
    int operator()(const std::string& key) const
    {
      return this->at(key);
    }
  };
 
 
  /**
   * Auxiliary class to map status bit to key.
   */
  struct JPutStatusBit :
    public std::map<int, std::string>
  {
    /**
     * Constructor.
     *
     * \param  input       status bits
     */
    JPutStatusBit(const JGetStatusBit& input)
    {
      using namespace std;
 
      for (JGetStatusBit::const_iterator i = input.begin(); i != input.end(); ++i) {
        this->insert(make_pair(i->second, i->first));
      }
    }
 
 
    /**
     * Put status bit.
     *
     * \param  bit        bit
     * \return            key
     */
    const std::string& operator()(const int bit) const
    {
      return this->at(bit);
    }
  };
 
 
  /**
   * Print status.
   *
   * \param  out        output stream
   * \param  status     status
   * \param  helper     helper
   */
  inline void print(std::ostream& out, const JStatus& status, const JPutStatusBit& helper)
  {
    using namespace std;
 
    for (const auto& i : helper) {
      out << setw(24) << left << i.second << right << status.has(i.first) << endl;
    }
  }
 
 
  /**
   * Print status.
   *
   * \param  out        output stream
   * \param  status     status
   * \param  helper     helper
   */
  inline void print(std::ostream& out, const JStatus& status, const JGetStatusBit& helper)
  {
    using namespace std;
 
    for (const auto& i : helper) {
      out << setw(24) << left << i.first << right << status.has(i.second) << endl;
    }
  }
}
 
#endif