parse_version_string.hpp

Go to the documentation of this file.

#ifndef RITSUKO_PARSE_VERSION_HPP
#define RITSUKO_PARSE_VERSION_HPP
 
#include <stdexcept>
#include <string>
 
namespace ritsuko {
 
struct Version {
    Version() = default;
 
    Version(int ma, int mi, int pa) {
        // Don't move to initializer list due to GCC's decision
        // to define a major() macro... thanks guys.
        major = ma;
        minor = mi;
        patch = pa;
    }
    int major = 0;
 
    int minor = 0;
 
    int patch = 0;
 
public:
    bool eq(int maj, int min, int pat) const {
        return (major == maj && minor == min && patch == pat);
    }
 
    bool ne(int maj, int min, int pat) const {
        return !eq(maj, min, pat);
    }
 
    bool le(int maj, int min, int pat) const {
        if (major == maj) {
            if (minor == min) {
                return patch <= pat;
            }
            return minor <= min;
        }
        return major <= maj;
    }
 
    bool lt(int maj, int min, int pat) const {
        if (major == maj) {
            if (minor == min) {
                return patch < pat;
            }
            return minor < min;
        }
        return major < maj;
    }
 
    bool ge(int maj, int min, int pat) const {
        return !lt(maj, min, pat);
    }
 
    bool gt(int maj, int min, int pat) const {
        return !le(maj, min, pat);
    }
 
public:
    bool operator==(const Version& rhs) const {
        return eq(rhs.major, rhs.minor, rhs.patch);
    }
 
    bool operator!=(const Version& rhs) const {
        return ne(rhs.major, rhs.minor, rhs.patch);
    }
 
    bool operator<(const Version& rhs) const {
        return lt(rhs.major, rhs.minor, rhs.patch);
    }
 
    bool operator<=(const Version& rhs) const {
        return le(rhs.major, rhs.minor, rhs.patch);
    }
 
    bool operator>(const Version& rhs) const {
        return gt(rhs.major, rhs.minor, rhs.patch);
    }
 
    bool operator>=(const Version& rhs) const {
        return ge(rhs.major, rhs.minor, rhs.patch);
    }
};
 
inline void throw_version_error(const char* version_string, size_t size, const char* reason) {
    std::string message(version_string, version_string + size);
    message = "invalid version string '" + message + "' ";
    message += reason;
    throw std::runtime_error(message.c_str());
}
inline Version parse_version_string(const char* version_string, size_t size, bool skip_patch = false) {
    int major = 0, minor = 0, patch = 0;
    size_t i = 0, end = size;
 
    // MAJOR VERSION.
    if (size == 0) {
        throw std::runtime_error("version string is empty");
    }
    if (version_string[i] == '0') {
        ++i;
        if (i < end && version_string[i] != '.') {
            throw_version_error(version_string, size, "has leading zeros in its major version");
        }
    } else {
        while (i < end && version_string[i] != '.') {
            if (!std::isdigit(version_string[i])) {
                throw_version_error(version_string, size, "contains non-digit characters");
            }
            major *= 10;
            major += version_string[i] - '0';
            ++i;
        }
    }
 
    // MINOR VERSION.
    if (i == end) {
        throw_version_error(version_string, size, "is missing a minor version");
    }
    ++i; // get past the period and check again.
    if (i == end) {
        throw_version_error(version_string, size, "is missing a minor version");
    }
 
    if (version_string[i] != '0') {
        while (i < end && version_string[i] != '.') {
            if (!std::isdigit(version_string[i])) {
                throw_version_error(version_string, size, "contains non-digit characters");
            }
            minor *= 10;
            minor += version_string[i] - '0';
            ++i;
        }
 
    } else {
        ++i;
        if (i < end && version_string[i] != '.') {
            throw_version_error(version_string, size, "has leading zeros in its minor version");
        }
    }
 
    if (skip_patch) {
        if (i != end) {
            throw_version_error(version_string, size, "should not have a patch version");
        }
        return Version(major, minor, 0);
    }
 
    // PATCH VERSION.
    if (i == end) {
        throw_version_error(version_string, size, "is missing a patch version");
    }
    ++i; // get past the period and check again.
    if (i == end) {
        throw_version_error(version_string, size, "is missing a patch version");
    }
 
    if (version_string[i] == '0' && i + 1 < end) {
        throw_version_error(version_string, size, "has leading zeros in its patch version");
    }
    while (i < end) {
        if (!std::isdigit(version_string[i])) {
            throw_version_error(version_string, size, "contains non-digit characters");
        }
        patch *= 10;
        patch += version_string[i] - '0';
        ++i;
    }
 
    return Version(major, minor, patch);
}
 
}
 
#endif