JPBS_t.hh

Go to the documentation of this file.

#ifndef __JDB__JPBS_T__
#define __JDB__JPBS_T__
 
#include <istream>
#include <ostream>
#include <sstream>
#include <string>
#include <vector>
 
#include <TROOT.h>
 
 
/**
 * \author mdejong
 */
namespace JDATABASE {}
namespace JPP { using namespace JDATABASE; }
 
namespace JDATABASE {
 
  /**
   * Product breakdown structure (%PBS).
   *
   * The %PBS consists of one (or more) integer value(s), separated by JPBS_t::DOT.\n
   * The corresponding ASCII format reads <tt>\"<int>[.<int>]*\"</tt>.
   */
  struct JPBS_t :
    public std::vector<int>
  {
    /**
     * Separator between %PBS values.
     */
    static const char DOT        =  '.';
 
 
    /**
     * Default constructor.
     */
    JPBS_t()
    {}
 
 
    /**
     * Constructor.
     *
     * Note that the parsing of arguments terminates at the first occurrence of a negative value.
     *
     * \param  i0           %PBS number
     * \param  i1           %PBS number
     * \param  i2           %PBS number
     * \param  i3           %PBS number
     * \param  i4           %PBS number
     * \param  i5           %PBS number
     * \param  i6           %PBS number
     * \param  i7           %PBS number
     * \param  i8           %PBS number
     * \param  i9           %PBS number
     */
    JPBS_t(const int i0,
           const int i1 = -1,
           const int i2 = -1,
           const int i3 = -1,
           const int i4 = -1,
           const int i5 = -1,
           const int i6 = -1,
           const int i7 = -1,
           const int i8 = -1,
           const int i9 = -1)
    {
      if (i0 >= 0) { push_back(i0); } else { return; }
      if (i1 >= 0) { push_back(i1); } else { return; }
      if (i2 >= 0) { push_back(i2); } else { return; }
      if (i3 >= 0) { push_back(i3); } else { return; }
      if (i4 >= 0) { push_back(i4); } else { return; }
      if (i5 >= 0) { push_back(i5); } else { return; }
      if (i6 >= 0) { push_back(i6); } else { return; }
      if (i7 >= 0) { push_back(i7); } else { return; }
      if (i8 >= 0) { push_back(i8); } else { return; }
      if (i9 >= 0) { push_back(i9); } else { return; }
    }
 
 
    /**
     * Constructor.
     *
     * \param  input        input text
     */
    JPBS_t(const std::string& input)
    {
      std::istringstream is(input);
 
      is >> *this;
    }
 
 
    /**
     * Get %PBS.
     *
     * \return              %PBS
     */
    const JPBS_t& getPBS() const
    {
      return static_cast<const JPBS_t&>(*this);
    }
 
 
    /**
     * Check validity.
     *
     * \return              true if valid; else false
     */
    bool is_valid() const
    {
      return !this->empty();
    }
 
 
    /**
     * Equality operator.
     *
     * \param  first        first  %PBS
     * \param  second       second %PBS
     * \return              true if %PBS is equal; else false
     */
    friend inline bool operator==(const JPBS_t& first, const JPBS_t& second)
    {
      if (first.size() == second.size()) {
 
        for (const_iterator p = first.begin(), q = second.begin(); p != first.end(); ++p, ++q) {
          if (*p != *q) {
            return false;
          }
        }
 
        return true;
      }
 
      return false;
    }
 
 
    /**
     * Less-than operator.
     *
     * \param  first        first  %PBS
     * \param  second       second %PBS
     * \return              true if first %PBS higher in hierarchy; else false
     */
    friend inline bool operator<(const JPBS_t& first, const JPBS_t& second)
    {
      for (const_iterator p = first.begin(), q = second.begin(); p != first.end() && q != second.end(); ++p, ++q) {
        if (*p != *q) {
          return *p < *q;
        }
      }
 
      return first.size() < second.size();
    }
 
 
    /**
     * Read %PBS from input stream.
     *
     * \param  in         input stream
     * \param  object     %PBS
     * \return            input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JPBS_t& object)
    {
      using namespace std;
 
      object.clear();
 
      int pbs;
 
      if (in >> pbs) {
 
        object.push_back(pbs);
 
        while (in.peek() == (int) JPBS_t::DOT) {
          if (in.ignore() && in >> pbs)
            object.push_back(pbs);
          else
            in.setstate(ios::failbit);
        }
 
      } else {
 
        in.setstate(ios::failbit);
      }
 
      return in;
    }
 
 
    /**
     * Write %PBS to output stream.
     *
     * \param  out        output stream
     * \param  object     %PBS
     * \return            output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JPBS_t& object)
    {
      using namespace std;
      using namespace JPP;
 
      ostringstream os;
 
      if (!object.empty()) {
 
        const_iterator i = object.begin();
 
        os << *i;
 
        while (++i != object.end()) {
          os << JPBS_t::DOT << *i;
        }
      }
      
      return out << os.str();
    }
 
    ClassDefNV(JPBS_t, 1);
  };
 
  /**
   * Namespace for predefined %PBS values.
   */
  namespace PBS {
    static const JPBS_t DETECTOR                   (0);                   //!< %PBS of detector
    static const JPBS_t DETECTION_UNIT             (3);                   //!< %PBS of detection unit
    static const JPBS_t CALIBRATION_UNIT           (4, 2);                //!< %PBS of caliration unit
    static const JPBS_t CALIBRATION_BASE_CONTAINER (4, 2, 2);             //!< %PBS of caliration base container
    static const JPBS_t BASE                       (3, 2);                //!< %PBS of detection unit base
    static const JPBS_t BASE_CONTAINER             (3, 2, 2);             //!< %PBS of detection unit base container
    static const JPBS_t DOM                        (3, 4);                //!< %PBS of optical module
    static const JPBS_t PMT                        (3, 4, 2, 3);          //!< %PBS of photo-multiplier tube             (PMT)
    static const JPBS_t CLB                        (3, 4, 3, 2);          //!< %PBS of central-logic board
    static const JPBS_t T_SENSOR                   (3, 4, 3, 2, 1, 1);    //!< %PBS of temperature sensor
    static const JPBS_t H_SENSOR                   (3, 4, 3, 2, 1, 2);    //!< %PBS of magnetic field sensor
    static const JPBS_t FPGA                       (3, 4, 3, 2, 2);       //!< %PBS of FPGA
    static const JPBS_t POWER_BOARD                (3, 4, 3, 5);          //!< %PBS of power board
    static const JPBS_t NANO_BEACON                (3, 4, 3, 7);          //!< %PBS of nano-beacon
    static const JPBS_t AHRS                       (3, 4, 3, 4);          //!< %PBS of compass
    static const JPBS_t ACOUSTIC_SENSOR            (3, 4, 3, 6, 2);       //!< %PBS of piezo sensor
    static const JPBS_t HYDROPHONE                 (4, 5);                //!< %PBS of hydrophone
  }
 
 
  /**
   * Test if given %PBS corresponds to a detector.
   *
   * \param  pbs        %PBS
   * \return            true if detector; else false
   */
  inline bool is_detector(const JPBS_t& pbs)
  {
    return (pbs == PBS::DETECTOR);
  }
 
 
  /**
   * Test if given %PBS corresponds to a string.
   *
   * \param  pbs        %PBS
   * \return            true if string; else false
   */
  inline bool is_string(const JPBS_t& pbs)
  {
    return (pbs == PBS::DETECTION_UNIT  ||
            pbs == PBS::CALIBRATION_UNIT);
  }
 
 
  /**
   * Test if given %PBS corresponds to a optical module.
   *
   * \param  pbs        %PBS
   * \return            true if optical module; else false
   */
  inline bool is_optical_module(const JPBS_t& pbs)
  {
    return (pbs == PBS::DOM);
  }
 
 
  /**
   * Test if given %PBS corresponds to a base module.
   *
   * \param  pbs        %PBS
   * \return            true if base module; else false
   */
  inline bool is_base_module(const JPBS_t& pbs)
  {
    return (pbs == PBS::BASE                      ||
            pbs == PBS::BASE_CONTAINER            ||
            pbs == PBS::CALIBRATION_BASE_CONTAINER);
  }
}
 
#endif