JUPI.hh

Go to the documentation of this file.

#ifndef __JDB__JUPI__
#define __JDB__JUPI__

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

#include <TROOT.h>

#include "JDB/JPBS.hh"


/**
 * \author mdejong
 */
namespace JDATABASE {}
namespace JPP { using namespace JDATABASE; }

namespace JDATABASE {

  /**
   * Universal product identifier (%UPI).
   *
   * The %UPI consists of a %PBS and a variant, seperated by JPBS::SEPARATOR.\n
   * The ASCII format should therefore read <tt>"<int>[.<int>]+/<variant>"</tt>.\n
   * The variant cannot start with any kind of white space.
   */
  struct JUPI :
    public JPBS
  {
    /**
     * Default constructor.
     */
    JUPI()
    {}


    /**
     * Constructor.
     *
     * \param  pbs          %PBS
     * \param  variant      variant
     */
    JUPI(const JPBS& pbs, const std::string& variant = "") :
      JPBS   (pbs),
      variant(variant)
    {}


    /**
     * Constructor.
     *
     * \param  upi          %UPI
     */
    JUPI(const std::string& upi)
    {
      std::istringstream(upi) >> *this;
    }


    /**
     * Get %UPI.
     *
     * \return              %UPI
     */
    const JUPI& getUPI() const
    {
      return static_cast<const JUPI&>(*this);
    }


    /**
     * Get variant.
     *
     * \return              variant
     */
    const std::string& getVariant() const
    {
      return variant;
    }


    /**
     * Equality.
     *
     * \param  first        first  %UPI
     * \param  second       second %UPI
     * \return              true if %UPIs are equals; else false
     */
    friend inline bool operator==(const JUPI& first, const JUPI& second)
    {
      return (first.getPBS()     == second.getPBS()    &&
              first.getVariant() == second.getVariant()); 
    }


    /**
     * Less-than operator.
     *
     * \param  first        first  %UPI
     * \param  second       second %UPI
     * \return              true if first %UPI higher in hierarchy or lesser variant; else false
     */
    friend inline bool operator<(const JUPI& first, const JUPI& second)
    {
      if (first.getPBS() == second.getPBS())
        return first.getVariant() < second.getVariant();
      else
        return first.getPBS()     < second.getPBS();
    }


    /**
     * Read %UPI from input stream.
     *
     * \param  in         input stream
     * \param  object     %UPI
     * \return            input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JUPI& object)
    {
      using namespace std;

      object.variant.clear();

      if (in >> static_cast<JPBS&>(object)) {

        if (in.get() == (int) JPBS::SEPARATOR) {

          const int c = in.peek();

          if (c != EOF && !isspace(c)) 
            in >> object.variant;
          else
            in.setstate(ios::failbit);

        } else {

          in.setstate(ios::failbit);
        }
      }

      return in;
    }


    /**
     * Write %UPI to output stream.
     *
     * \param  out        output stream
     * \param  object     %UPI
     * \return            output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JUPI& object)
    {
      using namespace std;

      ostringstream os;

      os << object.getPBS() << JPBS::SEPARATOR << object.getVariant();

      return out << os.str();
    }

    ClassDefNV(JUPI, 1);

  protected:
    std::string variant;
  };
}

#endif