JVersion.hh

Go to the documentation of this file.

#ifndef __JDETECTOR__JVERSION__
#define __JDETECTOR__JVERSION__

#include <istream>
#include <ostream>
#include <string>

#include "JLang/JEquals.hh"
#include "JIO/JSerialisable.hh"
#include "JIO/JSTDIO.hh"


/**
 * \author mdejong
 */

namespace JDETECTOR {}
namespace JPP { using namespace JDETECTOR; }

namespace JDETECTOR {

  using JLANG::JEquals;
  using JIO::JReader;
  using JIO::JWriter;

 
  /**
   * Auxiliary class for version identifier.
   */
  struct JVersion :
    public JEquals<JVersion>
  {
    /**
     * Default constructor.
     */
    JVersion() :
      __variant()
    {}

  
    /**
     * Constructor.
     *
     * \param  variant    variant
     */
    JVersion(const std::string& variant) :
      __variant(variant)
    {}


    /**
     * Get version.
     *
     * \return            version
     */
    const JVersion& getVersion() const
    { 
      return static_cast<const JVersion&>(*this);
    }


    /**
     * Get version.
     *
     * \return            version
     */
    JVersion& getVersion()
    { 
      return static_cast<JVersion&>(*this);
    }


    /**
     * Set version.
     *
     * \param  version    version
     */
    void setVersion(const JVersion& version)
    { 
      static_cast<JVersion&>(*this) = version;
    }


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


    /**
     * Set variant.
     *
     * \param  variant    variant
     */
    void setVariant(const std::string& variant)
    { 
      this->__variant = variant;
    }

    
    /**
     * Equal method.
     *
     * \param  version    version
     * \result            true if this version equal to given version; else false
     */
    inline bool equals(const JVersion& version) const
    {
      return this->getVariant() == version.getVariant();
    }

    
    /**
     * Read version from input.
     *
     * \param  in         input stream
     * \param  version    version
     * \return            input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JVersion& version)
    {
      return in >> version.__variant;
    }


    /**
     * Write version to output.
     *
     * \param  out        output stream
     * \param  version    version
     * \return            output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JVersion& version)
    {
      return out << version.__variant;
    }
  

    /**
     * Read version from input.
     *
     * \param  in         reader
     * \param  version    version
     * \return            reader
     */
    friend inline JReader& operator>>(JReader& in, JVersion& version)
    {
      return in >> version.__variant;
    }


    /**
     * Write version to output.
     *
     * \param  out        writer
     * \param  version    version
     * \return            writer
     */
    friend inline JWriter& operator<<(JWriter& out, const JVersion& version)
    {
      return out << version.__variant;
    }       
           
  protected:
    std::string __variant;
  };


  /**
   * Less-than operator for versions.
   *
   * \param  first      first  version
   * \param  second     second version
   * \return            true if first version before second; else false
   */
  bool inline operator<(const JVersion& first, const JVersion& second)
  {
    return first.getVariant() < second.getVariant();
  }
}

#endif