version_iface.hpp

/*
 Copyright 2024 Eugene Gershnik
 
 Use of this source code is governed by a BSD-style
 license that can be found in the LICENSE file or at
 https://github.com/gershnik/thinsqlitepp/blob/main/LICENSE
*/
 
#ifndef HEADER_SQLITEPP_VERSION_IFACE_INCLUDED
#define HEADER_SQLITEPP_VERSION_IFACE_INCLUDED
 
#include "config.hpp"
 
#include <tuple>
#include <limits>
#include <stdexcept>
 
namespace thinsqlitepp
{
 
    class sqlite_version
    {
    public:
        explicit constexpr sqlite_version(int val): _value(val) {}
 
        static constexpr sqlite_version from_parts(unsigned major, unsigned minor, unsigned release)
        { 
            if (release > 1000)
                throw std::runtime_error("invalid release value");
            int val = release;
            if (minor > 1000000)
                throw std::runtime_error("invalid minor value");
            val += minor*1000;
            if (major > unsigned((std::numeric_limits<int>::max() - val) / 1000000))
                throw std::runtime_error("invalid major value");
            val += major*1000000;
            return sqlite_version(val); 
        }
 
        constexpr std::tuple<unsigned, unsigned, unsigned> parts() const noexcept
        { 
            unsigned val = _value;
            unsigned major = val / 1000000;
            val -= (major * 1000000);
            unsigned minor = val / 1000;
            val -= (minor * 1000);
            unsigned release = val;
            return {major, minor, release};
        }
 
        constexpr int value() const noexcept
            { return _value; }
 
        static constexpr sqlite_version compile_time() noexcept
            { return sqlite_version(SQLITE_VERSION_NUMBER); }
 
        static sqlite_version runtime() noexcept
            { return sqlite_version(sqlite3_libversion_number()); }
 
        static constexpr const char * compile_time_str() noexcept
            { return SQLITE_VERSION; }
        static const char * runtime_str() noexcept
            { return sqlite3_libversion(); }
 
 
        static constexpr const char * compile_time_sourceid() noexcept
            { return SQLITE_SOURCE_ID; }
        
        static const char * runtime_sourceid() noexcept
            { return sqlite3_sourceid(); }
 
        friend constexpr bool operator==(const sqlite_version & lhs, const sqlite_version & rhs) noexcept
            { return lhs._value == rhs._value; }
        friend constexpr bool operator!=(const sqlite_version & lhs, const sqlite_version & rhs) noexcept
            { return lhs._value != rhs._value; }
 
    #if defined(DOXYGEN) || __cpp_impl_three_way_comparison >= 201907
        friend constexpr std::strong_ordering operator<=>(const sqlite_version & lhs, const sqlite_version & rhs) noexcept
            { return lhs._value <=> rhs._value; }
    #endif
        friend constexpr bool operator<(const sqlite_version & lhs, const sqlite_version & rhs) noexcept
            { return lhs._value < rhs._value; }
        friend constexpr bool operator<=(const sqlite_version & lhs, const sqlite_version & rhs) noexcept
            { return lhs._value <= rhs._value; }
        friend constexpr bool operator>(const sqlite_version & lhs, const sqlite_version & rhs) noexcept
            { return lhs._value > rhs._value; }
        friend constexpr bool operator>=(const sqlite_version & lhs, const sqlite_version & rhs) noexcept
            { return lhs._value >= rhs._value; }
        
    private:
        int _value;
    };
 
}
 
#endif