JPBS.hh

Go to the documentation of this file.

#ifndef __JDB__JPBS__
#define __JDB__JPBS__

#include <TROOT.h>

#include <istream>
#include <ostream>
#include <sstream>
#include <string>
#include <vector>


/**
 * \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::DOT.\n
   * The ASCII format should therefore read <tt>"<int>[.<int>]+"</tt>.
   */
  struct JPBS :
    public std::vector<int>
  {
    /**
     * Separator between %PBS values.
     */
    static const char DOT        =  '.';


    /**
     * Separator between %PBS and variant.
     */
    static const char SEPARATOR  =  '/';


    /**
     * Default constructor.
     */
    JPBS()
    {}


    /**
     * Constructor.
     *
     * \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(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 != -1) { push_back(i0); }
      if (i1 != -1) { push_back(i1); }
      if (i2 != -1) { push_back(i2); }
      if (i3 != -1) { push_back(i3); }
      if (i4 != -1) { push_back(i4); }
      if (i5 != -1) { push_back(i5); }    
      if (i6 != -1) { push_back(i6); }    
      if (i7 != -1) { push_back(i7); }    
      if (i8 != -1) { push_back(i8); }    
      if (i9 != -1) { push_back(i9); }    
    }


    /**
     * Constructor.
     *
     * \param  input        input text
     */
    JPBS(const std::string& input)
    {
      std::istringstream is(input);

      is >> *this;
    }


    /**
     * Get %PBS.
     *
     * \return              %PBS
     */
    const JPBS& getPBS() const
    {
      return static_cast<const JPBS&>(*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& first, const JPBS& 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& first, const JPBS& 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& object)
    {
      using namespace std;

      object.clear();

      int pbs;

      if (in >> pbs) {

        object.push_back(pbs);

        while (in.peek() == (int) JPBS::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& 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::DOT << *i;
        }
      }
      
      return out << os.str();
    }

    ClassDefNV(JPBS, 1);
  };


  namespace PBS {
    /**
     * Fixed %PBS.
     */
    static const JPBS DETECTOR       (0);
    static const JPBS DETECTION_UNIT (3);
    static const JPBS BASE           (3, 2);
    static const JPBS BASE_CONTAINER (3, 2, 2);
    static const JPBS DOM            (3, 4);
    static const JPBS PMT            (3, 4, 2, 3);
    static const JPBS CLB            (3, 4, 3, 2);
    static const JPBS T_SENSOR       (3, 4, 3, 2, 1, 1);
    static const JPBS H_SENSOR       (3, 4, 3, 2, 1, 2);
    static const JPBS FPGA           (3, 4, 3, 2, 2);
    static const JPBS POWER_BOARD    (3, 4, 3, 5);
    static const JPBS NANO_BEACON    (3, 4, 3, 7);
    static const JPBS AHRS           (3, 4, 3, 4);
  }
}

#endif