versioning.h

Namespaces

Name
libtextworker::versioning
libtextworker

Classes

	Name
class	libtextworker::versioning::VersioningException
class	libtextworker::versioning::Version
class	libtextworker::versioning::InvalidVersion

Types

	Name
enum class	VersionType { RELEASE, PRERELEASE, POSTRELEASE, DEVRELEASE}

Functions

	Name
void	require_lower(char * project, char * target_version)
void	require_exact(char * project, char * target_version)
void	require(char * project, char * target_version)
bool	is_development_version_from_project(char * project, char * version)
bool	is_development_version(char * version)

Attributes

	Name
char *	VERSION_PATTERN The pattern for a version string. Normally, this works: 1.2.3-dev+buffed.
std::map< char *, Version >	Requested

Types Documentation

enum VersionType

Enumerator	Value	Description
RELEASE
PRERELEASE
POSTRELEASE
DEVRELEASE

Functions Documentation

function require_lower

void require_lower(
    char * project,
    char * target_version
)

function require_exact

void require_exact(
    char * project,
    char * target_version
)

function require

void require(
    char * project,
    char * target_version
)

function is_development_version_from_project

bool is_development_version_from_project(
    char * project,
    char * version
)

function is_development_version

bool is_development_version(
    char * version
)

Attributes Documentation

variable VERSION_PATTERN

char * VERSION_PATTERN = "^(\\d+)\\.(\\d+)\\.(\\d+)(?:-(\\w+))?(?:\\+(\\w+))?$";

The pattern for a version string. Normally, this works: 1.2.3-dev+buffed.

variable Requested

static std::map< char *, Version > Requested;

Source code

#include <any>
#include <map>
#include <string>
#include <sstream>

namespace libtextworker
{
    namespace versioning
    {

        char* VERSION_PATTERN = "^(\\d+)\\.(\\d+)\\.(\\d+)(?:-(\\w+))?(?:\\+(\\w+))?$";

        class VersioningException : public std::exception
        {
        protected:
            std::string message;

        public:
            VersioningException(std::string msg) : message(msg) {}

            template <class ... Args>
            VersioningException(std::string firstarg, Args... args) {
                std::ostringstream oss;
                oss << firstarg;
                (oss << ... << (" " + std::to_string(args)));
                message = oss.str();
            }

            const std::string what() { return message; }
        };

        class InvalidVersion : public VersioningException
        {
        public:
            InvalidVersion(std::string version) : VersioningException("Invalid version: " + version) {};
        };

        enum class VersionType
        {
            PRERELEASE,
            POSTRELEASE,
            DEVRELEASE,
            RELEASE
        };

        class Version
        {
        public:
            Version(char* ver, int majorIndex = 0, int minorIndex = 1, int patchIndex = 2, int tag = 3);

            int major;
            int minor;
            int patch;

            VersionType type;

            bool operator ==(Version* object) {
                return (this->major == object->major) && (this->minor == object->minor) && (this->patch == object->patch);
            };

            bool operator >(Version* object) {
                return (this->major > object->major) && (this->minor > object->minor) && (this->patch > object->patch);
            };

            bool operator <(Version* object) {
                return (this->major < object->major) && (this->minor < object->minor) && (this->patch < object->patch);
            };
            
            bool operator >=(Version* object) {
                return (this > object) || (this == object);
            };

            bool operator <=(Version* object) {
                return (this < object) || (this == object);
            };
        };
        
        bool is_development_version(char* version);
        bool is_development_version_from_project(char* project, char* version);

        void require(char* project, char* target_version) {};
        void require_exact(char* project, char* target_version) {};
        void require_lower(char* project, char* target_version) {};

        static std::map<char*, Version> Requested;
    }
}

---

Updated on 2025-03-30 at 22:24:10 +0700