keywordEx.hpp

Go to the documentation of this file.

/**
 * @file
 * @ingroup daq_dpm_libmerge
 * @copyright ESO - European Southern Observatory
 */
#ifndef DAQ_DPM_KEYWORD_EX_HPP
#define DAQ_DPM_KEYWORD_EX_HPP
#include <algorithm>
#include <regex>
#include <string>
#include <string_view>
#include <vector>
 
#include <daq/fits/keyword.hpp>
 
namespace daq::dpm {
namespace detail {
 
/**
 * Rule operator
 */
enum class Operator : std::uint8_t { Include, Exclude };
 
/**
 * Rule scope.
 */
enum class Scope : std::uint8_t { Any, Value, Eso, Commentary };
 
/**
 * Represents a keyword rule expression.
 */
struct Rule {
    Operator op;
    Scope scope;
    std::string pattern;
};
 
/**
 * Parse expression of the form documented in KeywordEx
 *
 * @throw std::invalid_argument if expression @a ex is not valid.
 */
Rule ParseEx(std::string_view ex);
 
}  // namespace detail
 
/**
 * Create keyword expression that memoize the provided string pattern.
 *
 * Each rule string is defined by:
 *
 *    <rule> ::= <operator><scope> " " <pattern> | <operator> " " <pattern>
 *    <operator> ::= "+" | "-"
 *    <scope> ::= "v" | "e" | "c"
 *    <pattern> ::= <ascii-text> | <wildcard> | <pattern>
 *    <ascii-text> ::= [#x20 - #x7e]
 *    <wildcard> ::= "*" | "?" | "[" <ascii-text> "]"
 */
class KeywordEx {
public:
    KeywordEx() = default;
 
    /**
     * Construct expresssion from single rule.
     */
    explicit KeywordEx(std::string_view rule);
 
    /**
     * Construct from initilizer_list of c-strings.
     *
     * @param rules Initializer list of rules.
     */
    explicit KeywordEx(std::initializer_list<char const*> rules) {
        std::transform(
            std::begin(rules), std::end(rules), std::back_inserter(m_rules), [](auto&& value) {
                return detail::ParseEx(std::string_view(value));
            });
    }
 
    /**
     * Construct from a pair of iterators.
     *
     * @param begin beginning of sequence.
     * @param end end of sequence.
     */
    template <class ForwardIt,
              typename = typename std::enable_if_t<
                  std::is_constructible_v<std::string_view, typename ForwardIt::value_type>>>
    KeywordEx(ForwardIt begin, ForwardIt end) {
        std::transform(begin, end, std::back_inserter(m_rules), [](auto&& value) {
            return detail::ParseEx(std::string_view(value));
        });
    }
 
protected:
    constexpr std::vector<detail::Rule> const& GetRules() const noexcept {
        return m_rules;
    }
 
    friend bool KeywordMatch(fits::KeywordVariant const& keyword, KeywordEx const& ex);
 
private:
    std::vector<detail::Rule> m_rules;
};
 
/**
 *
 * @tparam Iterator An iterator type to a type that can be converted to a std::string_view, such as
 * char const**, std::vector<std::string>::const_iterator,
 * std::list<std::string_view>::const_iterator.
 */
bool KeywordMatch(fits::KeywordVariant const& keyword, KeywordEx const& ex);
 
/**
 * Transforms keyword name using regex
 *
 */
fits::KeywordVariant
KeywordTransform(fits::KeywordVariant const& keyword, std::regex const& re, char const* fmt);
 
fits::ValueKeyword
KeywordTransform(fits::ValueKeyword const& keyword, std::regex const& re, char const* fmt);
 
fits::EsoKeyword
KeywordTransform(fits::EsoKeyword const& keyword, std::regex const& re, char const* fmt);
 
fits::LiteralKeyword
KeywordTransform(fits::LiteralKeyword const& keyword, std::regex const& re, char const* fmt);
 
}  // namespace daq::dpm
 
#endif  // #ifndef DAQ_DPM_KEYWORD_EX_HPP