pre_parse_data.hpp

// Copyright (C) 2022-2023 by Camden Mannett.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE or copy at https://www.boost.org/LICENSE_1_0.txt)
 
#pragma once
 
#include "arg_router/parsing/parse_target.hpp"
 
namespace arg_router::parsing
{
namespace detail
{
struct always_returns_true {
    template <typename... Args>
    constexpr bool operator()([[maybe_unused]] Args&&... args) const noexcept
    {
        return true;
    }
};
}  // namespace detail
 
template <typename Validator, bool HasTarget>
class pre_parse_data_base
{
public:
    constexpr static auto has_target = HasTarget;
 
    [[nodiscard]] vector<parsing::token_type>& args() noexcept { return args_; }
 
    [[nodiscard]] const vector<parsing::token_type>& args() const noexcept { return args_; }
 
    [[nodiscard]] const Validator& validator() const noexcept { return validator_; }
 
protected:
    explicit pre_parse_data_base(
        vector<parsing::token_type>& args,
        const Validator& validator = [](const auto&...) { return true; }) noexcept :
        args_{args},
        validator_{validator}
    {
    }
 
private:
    std::reference_wrapper<vector<parsing::token_type>> args_;
    std::reference_wrapper<const Validator> validator_;
};
 
template <typename Validator, bool>
class pre_parse_data;
 
template <typename Validator>
class pre_parse_data<Validator, false> : public pre_parse_data_base<Validator, false>
{
public:
    explicit pre_parse_data(vector<parsing::token_type>& args,
                            const Validator& validator = detail::always_returns_true{}) noexcept :
        pre_parse_data_base<Validator, false>{args, validator}
    {
    }
};
 
template <typename Validator>
class pre_parse_data<Validator, true> : public pre_parse_data_base<Validator, true>
{
public:
    pre_parse_data(vector<parsing::token_type>& args,
                   const parse_target& target,
                   const Validator& validator = detail::always_returns_true{}) noexcept :
        pre_parse_data_base<Validator, true>{args, validator},
        target_{target}
    {
    }
 
    [[nodiscard]] const parse_target& target() const noexcept { return target_; }
 
private:
    std::reference_wrapper<const parse_target> target_;
};
 
// Deduction guides
template <typename... T>
pre_parse_data(vector<parsing::token_type>&) -> pre_parse_data<detail::always_returns_true, false>;
 
template <typename T>
pre_parse_data(vector<parsing::token_type>&, const T&) -> pre_parse_data<T, false>;
 
template <typename... T>
pre_parse_data(vector<parsing::token_type>&, const parse_target&)
    -> pre_parse_data<detail::always_returns_true, true>;
 
template <typename T>
pre_parse_data(vector<parsing::token_type>&, const parse_target&, const T&)
    -> pre_parse_data<T, true>;
}  // namespace arg_router::parsing