Exceptions.hpp

Go to the documentation of this file.

#pragma once

#include <vector>
#include <stdexcept>
#include <memory>

namespace TAP {

class exception : public std::exception {
protected:
    std::string m_what;

public:
    exception(std::string what) : std::exception(), m_what(what) {};

    exception() : std::exception(), m_what() {};

    const char* what() const noexcept override {
        return m_what.c_str();
    }
};

class command_error: public exception {
public:
    using exception::exception;
};

class unknown_argument : public command_error {
public:
    unknown_argument() :
        command_error("No positional arguments are supported") {
    }

    unknown_argument(char flag) :
        command_error(std::string("The flag argument ") + flag + " is unknown") {
    }

    unknown_argument(std::string name) :
        command_error(std::string("The named argument ") + name + " is unknown") {
    }
};

class argument_error : public exception {
protected:
    std::unique_ptr<Argument> m_arg;

public:
    argument_error(const Argument& arg);

    argument_error(const Argument& arg, const std::string& reason);

    const Argument& arg() const {
        return *m_arg;
    }
};

class argument_count_mismatch : public argument_error {
public:
    argument_count_mismatch(const Argument& arg, unsigned int count, unsigned int expected) :
        argument_error(arg) {
        if (count < expected) {
            if (expected > 1) {
                m_what += " is required to occur at least " + std::to_string(expected) + " times";
            } else {
                m_what += " is required";
            }
        } else {
            if (expected > 1) {
                m_what += " can occur at most " + std::to_string(expected) + " times";
            } else {
                m_what += " can only be set once";
            }
        }
    }
};

class argument_invalid_value : public argument_error {
public:
    argument_invalid_value(const Argument& arg, const std::string& value) :
        argument_error(arg, std::string("does not accept the value ") + value) {
    }
};

class argument_missing_value : public argument_error {
public:
    argument_missing_value(const Argument& arg) :
        argument_error(arg, "requires a value") {
    }
};

class argument_no_value : public argument_error {
public:
    argument_no_value(const Argument& arg) :
        argument_error(arg, "does not accept a value") {
    }
};

class constraint_error : public exception {
public:
    constraint_error(const std::string& reason, const std::vector<const BaseArgument*>& args);
};
}