Jeep/JVersion.hh

Go to the documentation of this file.

#ifndef __JEEP_JVERSION__
#define __JEEP_JVERSION__

#include <istream>
#include <ostream>

#include "JLang/JException.hh"
#include "JLang/JComparable.hh"

#include "Jeep/JPrint.hh"


/**
 * \author bjung
 */

namespace JEEP {};
namespace JPP { using namespace JEEP; }

/**
 * Auxiliary class for I/O of version number.
 */
namespace JEEP {

  using JLANG::JComparable;
  using JLANG::JValueOutOfRange;


  /**
   * Auxiliary data structure for I/O of version number.
   */
  struct JVersion :
    public JComparable<JVersion>
  {
    static const char SEPARATOR = '.';
    
    /**
     * Default constructor.
     */
    JVersion() :
      majorVersion(0),
      minorVersion(0),
      patchVersion(0)
    {}
    
    
    /**
     * Constructor.
     *
     * \param  major           major version
     * \param  minor           minor version
     * \param  patch           patch version
     */
    JVersion(const int major,
             const int minor,
             const int patch) :
      majorVersion(major),
      minorVersion(minor),
      patchVersion(patch)
    {}
    
    
    /**
     * Get major version.
     *
     * \return                 major version.
     */
    int getMajorVersion() const
    {
      return majorVersion;
    }


    /**
     * Get minor version.
     *
     * \return                 minor version.
     */
    int getMinorVersion() const
    {
      return minorVersion;
    }


    /**
     * Get patch version.
     *
     * \return                 patch version.
     */
    int getPatchVersion() const
    {
      return patchVersion;
    }


    /**
     * Compare database API version.
     *
     * \param  object          true if this version is less than given version; else false  
     */
    bool less(const JVersion& object) const
    {
      if (this->majorVersion == object.majorVersion) {

        if (this->minorVersion == object.minorVersion) {

          return this->patchVersion < object.patchVersion;
          
        } else {

          return this->minorVersion < object.minorVersion;
        }
        
      } else {
        
        return this->majorVersion < object.majorVersion;
      }
    }
    

    /**
     * Read in version from input stream.
     *
     * \param  in              input stream
     * \param  object          database API version
     * \return                 input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JVersion& object)
    {
      using namespace std;

      unsigned int version;

      if (in >> version) {
        object.majorVersion = version;
      } else {
        in.setstate(ios::failbit);
      }

      if ((in.peek() == (int) JVersion::SEPARATOR) && (in.ignore() && in >> version)) {
        object.minorVersion = version;
      } else {
        in.setstate(ios::failbit);
      }

      if ((in.peek() == (int) JVersion::SEPARATOR) && (in.ignore() && in >> version)) {
        object.patchVersion = version;
      } else {
        in.setstate(ios::failbit);
      }

      return in;
    }


    /**
     * Write version to output stream.
     *
     * \param  out             output stream
     * \param  object          database API version
     * \return                 output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JVersion& object)
    {
      return out <<
        object.majorVersion << JVersion::SEPARATOR <<
        object.minorVersion << JVersion::SEPARATOR <<
        object.patchVersion;
    }

    
  protected:

    unsigned int majorVersion;   //!< API major version
    unsigned int minorVersion;   //!< API minor version
    unsigned int patchVersion;   //!< API patch version
  };
}

#endif