Version.cpp

Go to the documentation of this file.

 
#include "rogue/Directives.h"
 
#include "rogue/Version.h"
 
#include <RogueConfig.h>
#include <inttypes.h>
#include <unistd.h>
 
#include <cstdio>
#include <mutex>
#include <sstream>
#include <string>
 
#include "rogue/GeneralError.h"
#include "rogue/GilRelease.h"
 
#ifndef NO_PYTHON
    #include <boost/python.hpp>
namespace bp = boost::python;
#endif
 
const char rogue::Version::_version[]      = ROGUE_VERSION;
std::atomic<uint32_t> rogue::Version::_major{0};
std::atomic<uint32_t> rogue::Version::_minor{0};
std::atomic<uint32_t> rogue::Version::_maint{0};
std::atomic<uint32_t> rogue::Version::_devel{0};
 
void rogue::Version::init() {
    static std::once_flag flag_;
 
    std::call_once(flag_, []() {
        char dump[100];
        char lead;
        uint32_t maj = 0, min = 0, mnt = 0, dev = 0;
        int32_t ret  = sscanf(_version,
                              "%c%" SCNu32 ".%" SCNu32 ".%" SCNu32 "-%" SCNu32 "-%99s",
                              &lead,
                              &maj,
                              &min,
                              &mnt,
                              &dev,
                              dump);
 
        if ((ret != 4 && ret != 6) || (lead != 'v' && lead != 'V'))
            throw(rogue::GeneralError("Version:init", "Invalid compiled version string"));
 
        _major.store(maj);
        _minor.store(min);
        _maint.store(mnt);
        _devel.store(dev);
    });
}
 
void rogue::Version::extract(const std::string& compare, uint32_t* major, uint32_t* minor, uint32_t* maint) {
    if (sscanf(compare.c_str(), "%" PRIu32 ".%" PRIu32 ".%" PRIu32, major, minor, maint) != 3)
        throw(rogue::GeneralError("Version:extract", "Invalid version string"));
}
 
std::string rogue::Version::current() {
    std::string ret = _version;
    return ret;
}
 
bool rogue::Version::greaterThanEqual(const std::string& compare) {
    uint32_t cmajor, cminor, cmaint;
    init();
    extract(compare, &cmajor, &cminor, &cmaint);
    if (cmajor != _major) return (_major > cmajor);
    if (cminor != _minor) return (_minor > cminor);
    if (cmaint != _maint) return (_maint > cmaint);
    return (true);
}
 
bool rogue::Version::greaterThan(const std::string& compare) {
    uint32_t cmajor, cminor, cmaint;
    init();
    extract(compare, &cmajor, &cminor, &cmaint);
    if (cmajor != _major) return (_major > cmajor);
    if (cminor != _minor) return (_minor > cminor);
    if (cmaint != _maint) return (_maint > cmaint);
    return (false);
}
 
bool rogue::Version::lessThanEqual(const std::string& compare) {
    uint32_t cmajor, cminor, cmaint;
    init();
    extract(compare, &cmajor, &cminor, &cmaint);
    if (cmajor != _major) return (_major < cmajor);
    if (cminor != _minor) return (_minor < cminor);
    if (cmaint != _maint) return (_maint < cmaint);
    return (true);
}
 
bool rogue::Version::lessThan(const std::string& compare) {
    uint32_t cmajor, cminor, cmaint;
    init();
    extract(compare, &cmajor, &cminor, &cmaint);
    if (cmajor != _major) return (_major < cmajor);
    if (cminor != _minor) return (_minor < cminor);
    if (cmaint != _maint) return (_maint < cmaint);
    return (false);
}
 
void rogue::Version::minVersion(const std::string& compare) {
    if (lessThan(compare))
        throw(rogue::GeneralError("Version:minVersion", "Installed rogue is less than minimum version"));
}
 
void rogue::Version::maxVersion(const std::string& compare) {
    if (greaterThan(compare))
        throw(rogue::GeneralError("Version:maxVersion", "Installed rogue is greater than maximum version"));
}
 
void rogue::Version::exactVersion(const std::string& compare) {
    if (lessThan(compare) || greaterThan(compare))
        throw(rogue::GeneralError("Version:exactVersion", "Installed rogue is not exact version"));
}
 
uint32_t rogue::Version::getMajor() {
    init();
    return _major;
}
 
uint32_t rogue::Version::getMinor() {
    init();
    return _minor;
}
 
uint32_t rogue::Version::getMaint() {
    init();
    return _maint;
}
 
uint32_t rogue::Version::getDevel() {
    init();
    return _devel;
}
 
std::string rogue::Version::pythonVersion() {
    init();
    std::stringstream ret;
 
    ret << std::dec << _major;
    ret << "." << std::dec << _minor;
    ret << "." << std::dec << _maint;
 
    if (_devel > 0) ret << ".dev" << std::dec << _devel;
    return ret.str();
}
 
void rogue::Version::sleep(uint32_t seconds) {
    rogue::GilRelease noGil;
    ::sleep(seconds);
}
 
void rogue::Version::usleep(uint32_t useconds) {
    rogue::GilRelease noGil;
    ::usleep(useconds);
}
 
void rogue::Version::setup_python() {
#ifndef NO_PYTHON
    bp::class_<rogue::Version, boost::noncopyable>("Version", bp::no_init)
        .def("current", &rogue::Version::current)
        .staticmethod("current")
        .def("greaterThanEqual", &rogue::Version::greaterThanEqual)
        .staticmethod("greaterThanEqual")
        .def("greaterThan", &rogue::Version::greaterThan)
        .staticmethod("greaterThan")
        .def("lessThanEqual", &rogue::Version::lessThanEqual)
        .staticmethod("lessThanEqual")
        .def("lessThan", &rogue::Version::lessThan)
        .staticmethod("lessThan")
        .def("minVersion", &rogue::Version::minVersion)
        .staticmethod("minVersion")
        .def("maxVersion", &rogue::Version::maxVersion)
        .staticmethod("maxVersion")
        .def("exactVersion", &rogue::Version::exactVersion)
        .staticmethod("exactVersion")
        .def("major", &rogue::Version::getMajor)
        .staticmethod("major")
        .def("minor", &rogue::Version::getMinor)
        .staticmethod("minor")
        .def("maint", &rogue::Version::getMaint)
        .staticmethod("maint")
        .def("devel", &rogue::Version::getDevel)
        .staticmethod("devel")
        .def("pythonVersion", &rogue::Version::pythonVersion)
        .staticmethod("pythonVersion")
        .def("sleep", &rogue::Version::sleep)
        .staticmethod("sleep")
        .def("usleep", &rogue::Version::usleep)
        .staticmethod("usleep");
#endif
}