Jeep/JVersion.hh

Go to the documentation of this file.

#ifndef __JEEP_JVERSION__
#define __JEEP_JVERSION__
 
#include <istream>
#include <ostream>
#include <sstream>
 
#include "JLang/JComparable.hh"
 
 
/**
 * \author bjung
 */
 
namespace JEEP {};
namespace JPP { using namespace JEEP; }
 
namespace JEEP {
 
  using JLANG::JComparable;
 
  /**
   * Auxiliary data structure for general purpose version number.
   *
   * A version consists of a major, minor and patch number.\n
   * The I/O format is <major>.<minor>.<patch>.
   */
  struct JVersion :
    public JComparable<JVersion>
  {
    /**
     * Type definition of [sub-]versions.
     */
    typedef unsigned int  version_type;
 
 
    /**
     * Separator between [sub-]versions.
     */
    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 version_type major,
             const version_type minor,
             const version_type patch) :
      majorVersion(major),
      minorVersion(minor),
      patchVersion(patch)
    {}
    
     
    /**
     * Constructor.
     *
     * \param  version         version
     */
    JVersion(const std::string& version) :
      majorVersion(0),
      minorVersion(0),
      patchVersion(0)
    {
      std::istringstream is(version);
 
      is >> *this;
    }
    
    
    /**
     * Get major version.
     *
     * \return                 major version.
     */
    version_type getMajorVersion() const
    {
      return majorVersion;
    }
 
 
    /**
     * Get minor version.
     *
     * \return                 minor version.
     */
    version_type getMinorVersion() const
    {
      return minorVersion;
    }
 
 
    /**
     * Get patch version.
     *
     * \return                 patch version.
     */
    version_type getPatchVersion() const
    {
      return patchVersion;
    }
 
 
    /**
     * Compare version.
     *
     * \param  version         version
     * \return                 true if this version is less than given version; else false  
     */
    bool less(const JVersion& version) const
    {
      if (this->majorVersion == version.majorVersion) {
 
        if (this->minorVersion == version.minorVersion) {
 
          return this->patchVersion < version.patchVersion;
          
        } else {
 
          return this->minorVersion < version.minorVersion;
        }
        
      } else {
        
        return this->majorVersion < version.majorVersion;
      }
    }
    
 
    /**
     * Convert version to string.
     *
     * \return                 string
     */
    std::string toString() const
    {
      std::ostringstream os;
 
      os << *this;
 
      return os.str();
    }
 
 
    /**
     * Read version from input stream.
     *
     * \param  in              input stream
     * \param  object          version
     * \return                 input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JVersion& object)
    {
      using namespace std;
 
      version_type 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          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:
    version_type majorVersion;   //!< major version
    version_type minorVersion;   //!< minor version
    version_type patchVersion;   //!< patch version
  };
}
 
#endif