option_set.hpp

// The MIT License (MIT)

// Copyright (c) 2012-2014 Danny Y., Rapptz

// Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in
// the Software without restriction, including without limitation the rights to
// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
// the Software, and to permit persons to whom the Software is furnished to do so,
// subject to the following conditions:

// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

#ifndef GEARS_OPTPARSE_OPTION_SET_HPP
#define GEARS_OPTPARSE_OPTION_SET_HPP

#include "option.hpp"
#include <set>
#include <vector>
#include <algorithm>

namespace gears {
namespace optparse {
namespace detail {
struct option_comparison {
    bool operator()(const option& lhs, const option& rhs) const {
        return lhs.name < rhs.name || (lhs.name == rhs.name && lhs.alias < rhs.alias);
    }
};
} // detail

struct option_set {
private:
    std::set<option, detail::option_comparison> cache;
    std::vector<option> options;
public:
    option_set(bool help = true) {
        if(help) {
            options.emplace_back("help", 'h', "shows this message and exits");
            cache.insert(options.back());
        }
    }

    option_set(std::initializer_list<option> l) {
        options.emplace_back("help", 'h', "shows this message and exits");
        cache.insert(options.back());

        for(auto&& i : l) {
            if(cache.count(i)) {
                continue;
            }

            cache.insert(i);
            options.push_back(i);
        }
    }

    template<typename... Args>
    void add(Args&&... args) {
        // emplace it to the vector
        options.emplace_back(std::forward<Args>(args)...);

        // check if it's in the cache and remove it if so
        auto&& it = cache.find(options.back());
        if(it != cache.end()) {
            options.pop_back();
        }

        cache.insert(options.back());
    }

    template<typename Argument>
    option_set& remove(const Argument& arg) {
        auto&& it = std::find_if(options.begin(), options.end(), [&arg](const option& opt) {
            return opt.is(arg);
        });

        if(it != options.end()) {
            cache.erase(*it);
            options.erase(it);
        }
        return *this;
    }

    template<typename T, typename Argument>
    const T& get(const Argument& arg) const {
        auto&& it = std::find_if(options.begin(), options.end(), [&arg](const option& opt) {
            return opt.is(arg);
        });

        if(it == options.end()) {
            throw std::invalid_argument("option not found");
        }

        return it->template get<T>();
    }

    template<typename T, typename Argument>
    const T& get_or(const Argument& arg, const typename std::remove_reference<T>::type& def) const noexcept {
        auto&& it = std::find_if(options.begin(), options.end(), [&arg](const option& opt) {
            return opt.is(arg);
        });

        if(it == options.end()) {
            return def;
        }

        return it->template get_or<T>(def);
    }

    template<typename Argument>
    bool is_active(const Argument& arg) const noexcept {
        auto&& it = std::find_if(options.begin(), options.end(), [&arg](const option& opt) {
            return opt.is(arg);
        });

        return it != options.end() && it->is_active();
    }

    size_t size() const noexcept {
        return options.size();
    }

    bool empty() const noexcept {
        return options.empty();
    }


    auto begin() noexcept -> decltype(options.begin()) {
        return options.begin();
    }

    auto begin() const noexcept -> decltype(options.begin()) {
        return options.begin();
    }


    auto end() noexcept -> decltype(options.end()) {
        return options.end();
    }

    auto end() const noexcept -> decltype(options.end()) {
        return options.end();
    }
};
} // optparse
} // gears

#endif // GEARS_OPTPARSE_OPTION_SET_HPP