JPBS.hh

Go to the documentation of this file.

#ifndef __JDB__JPBS__
#define __JDB__JPBS__
 
#include <istream>
#include <ostream>
#include <sstream>
#include <string>
#include <vector>
 
#include "JLang/JEquals.hh"
 
 
/**
 * \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>,
    public JLANG::JEquals<JPBS>
  {
    /**
     * 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.
     *
     * \param  pbs          %PBS
     * \return              true if %PBS is equal; else false
     */
    bool equals(const JPBS& pbs) const
    {
      if (this->size() == pbs.size()) {
 
        for (const_iterator p = this->begin(), q = pbs.begin(); p != this->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;
 
      if (!object.empty()) {
 
        const_iterator i = object.begin();
 
        out << *i;
 
        while (++i != object.end()) {
          out << JPBS::DOT << *i;
        }
      }
      
      return out;
    }
  };
 
 
  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);
  }
}
 
#endif