keywordRule.hpp

Go to the documentation of this file.

/**
 * @file
 * @ingroup daq_dpm_libmerge
 * @copyright ESO - European Southern Observatory
 */
#ifndef DAQ_DPM_KEYWORD_RULE_HPP
#define DAQ_DPM_KEYWORD_RULE_HPP
#include <vector>
 
#include <daq/dpm/keywordEx.hpp>
#include <daq/fits/keyword.hpp>
 
namespace daq::dpm {
 
/**
 * Interface for keyword rule processors
 */
class KeywordRuleProcessor {
public:
    enum class DefaultRule {
        /**
         * Default rule is to keep all keywords (useful for in-place merge)
         */
        All,
        /**
         * Default is to keep only user-keywords.
         */
        User,
 
        /**
         * None (to disable keyword copying)
         */
        None,
    };
    virtual fits::KeywordVector
    Process(fits::KeywordVector const&, DefaultRule default_rule) const = 0;
    virtual ~KeywordRuleProcessor() noexcept = default;
};
 
class StandardKeywordRuleProcessor : public KeywordRuleProcessor {
public:
    using Rule = std::function<fits::KeywordVector(fits::KeywordVector const&)>;
 
    StandardKeywordRuleProcessor() = default;
    virtual fits::KeywordVector
    Process(fits::KeywordVector const& keywords, DefaultRule default_rule) const override;
 
    void AddRule(Rule rule) {
        m_rules.emplace_back(std::move(rule));
    }
 
private:
    std::vector<Rule> m_rules;
};
 
template <class InputIt, class OutputIt>
constexpr OutputIt
Filter(InputIt first, InputIt last, OutputIt d_first, KeywordEx const& filter_ex) {
    return std::copy_if(
        first, last, d_first, [&filter_ex](auto const kw) { return KeywordMatch(kw, filter_ex); });
}
 
template <class InputIt, class OutputIt>
OutputIt Transform(InputIt first,
                   InputIt last,
                   OutputIt d_first,
                   KeywordEx const& filter_ex,
                   std::regex const& regex,
                   char const* fmt) {
    while (first != last) {
        if (KeywordMatch(*first, filter_ex)) {
            *d_first++ = KeywordTransform(*first, regex, fmt);
        } else {
            *d_first++ = *first;
        }
        ++first;
    }
    return d_first;
}
 
}  // namespace daq::dpm
#endif  // #ifndef DAQ_DPM_KEYWORD_RULE_HPP