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 "JLang/JEquals.hh"
#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,
    public JLANG::JEquals<JUPI>
  {
    /**
     * 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  upi          %UPI
     * \return              true if %UPIs are equals; else false
     */
    bool equals(const JUPI& upi) const
    {
      return (this->getPBS()     == upi.getPBS()    &&
              this->getVariant() == upi.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)
    {
      return out << object.getPBS() << JPBS::SEPARATOR << object.getVariant();
    }
 
  protected:
    std::string variant;
  };
}
 
#endif