ArgsParser/src/ArgsParser.cpp

#include <ArgsParser.hpp>
#include <algorithm>

ArgsParser::ArgsParser(int argc, char **argv, bool keep_program_name) {
    args = std::vector<std::string>(argv, argv+argc);
}

bool ArgsParser::empty() const { return args.empty();}

bool ArgsParser::has_next() const {
    return !args.empty();
}

std::string ArgsParser::get_next() const {
    return args[0];
}

std::string ArgsParser::consume_next() {
    std::string value = args[0];

    args.erase(args.begin());

    return value;
}

bool ArgsParser::has_flag(const std::string &option) {
    return std::ranges::find(args, option) != args.end();
}

bool ArgsParser::has_flag(const std::initializer_list<std::string> &flags) {
    for (auto& flag : flags)
        if (has_flag(flag))
            return true;

    return false;
}

bool ArgsParser::consume_flag(const std::string &option) {
    if (has_flag(option)) {
        args.erase(std::remove(args.begin(), args.end(), option), args.end());
        return true;
    }
    return false;
}

bool ArgsParser::consume_flag(const std::initializer_list<std::string> &flags) {
    bool had_any_flag = false;
    for (auto& flag : flags) {
        if (has_flag(flags)) {
            had_any_flag = true;
            args.erase(std::remove(args.begin(), args.end(), flag), args.end());
        }
    }
    return had_any_flag;
}

bool ArgsParser::has_flag_arg(const std::string &option) {
    if (has_flag(option)) {
        auto it = std::ranges::find(args, option);
        return it!=args.end() && ++it!=args.end();
    }

    return false;
}


std::optional<std::string> ArgsParser::get_flag_arg(const std::string &option) {
    auto it = std::ranges::find(args, option);
    ++it;

    return  *it;
}

std::optional<std::string> ArgsParser::consume_flag_arg(const std::string &flag) {
    if (has_flag_arg(flag)) {
        auto it = std::ranges::find(args, flag);

        ++it;

        std::string ret_val = std::string(*it);
        args.erase(std::remove(args.begin(), args.end(), flag), args.end());
        args.erase(std::remove(args.begin(), args.end(), ret_val), args.end());

        return ret_val;
    }

    return std::nullopt;
}

std::optional<std::string> ArgsParser::consume_flag_arg(const std::initializer_list<std::string> &flags) {
    for (auto& flag : flags) {
        if (has_flag_arg(flag))
            return consume_flag_arg(flag);
    }
}

std::vector<std::string> ArgsParser::get_remaining_args() const {
    return args;
}

bool ArgsParser::contains(const std::string &token) const {
    return std::ranges::find(args, token) != args.end();
}

bool ArgsParser::has_flag_contains(const std::string &match) const {
    for (auto& token : args) {
        if (token.find(match) != std::string::npos)
            return true;
    }

    return false;
}

std::optional<std::string> ArgsParser::get_flag_contains(std::string &match) {
    for (auto& token : args) {
        if (token.find(match) != std::string::npos)
            return token;
    }

    return std::nullopt;
}

bool ArgsParser::has_flag_starts_with(const std::string &value) const {
    for (auto& token : args) {
        if (token.starts_with(value))
            return true;
    }

    return false;
}

std::string ArgsParser::get_flag_starts_with(const std::string &prefix) const {
    for (auto& token : this->args) {
        if (token.starts_with(prefix))
            return token;
    }
}

std::vector<std::string> ArgsParser::consume_flag_arg_multiple(const std::string &flag) {
    std::vector<std::string> ret_val;

    for (auto it = args.begin(); it != args.end();) {
        if (*it == flag) {
            if (it != args.end()) {
                ret_val.push_back(*std::next(it, 1).base());
                it = args.erase(it, it+1);

                //args.erase(it);
            }
        } else
            ++it;

        //++it;
    }
    return ret_val;
}

std::vector<std::string> ArgsParser::consume_flag_arg_multiple(const std::initializer_list<std::string> &flag_aliases) {
    std::vector<std::string> ret_val;
    for (auto& flag : flag_aliases) {
        std::vector<std::string> pass = consume_flag_arg_multiple(flag);
        for (auto& val : pass) {
            ret_val.push_back(val);
        }
    }
    return ret_val;
}