gearLoader.hpp

#ifndef GEARLOADER_HPP
#define GEARLOADER_HPP
 
#include "gearLoader_c.h"
#include <string>
 
 
inline bool operator==(const SemanticVersion& a, const SemanticVersion& b) {
    return a.major == b.major &&
        a.minor == b.minor &&
        a.patchNum == b.patchNum;
}
inline bool operator>(const SemanticVersion& a, const SemanticVersion& b) {
    return a.major > b.major ||
        (a.major == b.major && a.minor > b.minor) ||
        (a.major == b.major && a.minor == b.minor && a.patchNum > b.patchNum);
}
inline bool operator!=(const SemanticVersion& a, const SemanticVersion& b) { return !(a == b); }
inline bool operator<(const SemanticVersion& a, const SemanticVersion& b) { return b > a; }
inline bool operator>=(const SemanticVersion& a, const SemanticVersion& b) { return !(b > a); }
inline bool operator<=(const SemanticVersion& a, const SemanticVersion& b) { return !(a > b); }
 
namespace GearLoader {
    enum class LogLevel {
        DEBUG = GEARLOADER_LOG_LEVEL_DEBUG,
        INFO = GEARLOADER_LOG_LEVEL_INFO,
        WARN = GEARLOADER_LOG_LEVEL_WARN,
        ERR = GEARLOADER_LOG_LEVEL_ERR,
        VERBOSE = GEARLOADER_LOG_LEVEL_VERBOSE
    };

    class Api {
    public:
        Api(GearLoaderApi* c_api, GearLoaderContext* ctx) : base(c_api), _ctx(ctx) { }
        bool VersionError() {
            return (GEARLOADER_VERSION_NUM & 0xFF0000) != (base->version & 0xFF0000);
        }

        template<typename ApiType>
        int RetrieveModApi(std::string name,
                           std::string versionConstraint,
                           const ApiType** pApi,
                           SemanticVersion* retrievedVersion) {
            if (VersionError()) return 3;
 
            const void* retApi;
            int result = base->RetrieveModApi(
                _ctx,
                name.c_str(),
                versionConstraint.c_str(),
                &retApi,
                retrievedVersion
            );
            *pApi = reinterpret_cast<const ApiType*>(retApi);
            return result;
        }

        int RegisterApi (const void* api,
                         std::string name,
                         SemanticVersion version) {
            if (VersionError()) return 3;
            return base->RegisterApi(_ctx, api, name.c_str(), version);
        }

        int Log(LogLevel logLevel, std::string str) {
            if (VersionError()) return 3;
            return base->Log(_ctx, static_cast<uint32_t>(logLevel), str.c_str());
        }
    private:
        GearLoaderApi* base;
        GearLoaderContext* _ctx;
    };
}
 
#endif