keywordEx.cpp

Go to the documentation of this file.

/**
 * @file
 * @ingroup daq_dpm_libmerge
 * @copyright ESO - European Southern Observatory
 */
#include <daq/dpm/keywordEx.hpp>
 
#include <fmt/format.h>
#include <fmt/ostream.h>
#include <fnmatch.h>
 
#include <daq/fits/keyword.hpp>
 
namespace daq::dpm {
namespace detail {
 
Rule ParseEx(std::string_view ex) {
    auto it = std::begin(ex);
    auto end = std::end(ex);
 
    if (it == end) {
        throw std::invalid_argument("empty expression is invalid");
    }
 
    // Operator
    Operator op;
    switch (*it) {
    case '+':
        op = Operator::Include;
        break;
    case '-':
        op = Operator::Exclude;
        break;
    default:
        throw std::invalid_argument(fmt::format(
            "invalid operator '{}', must be one of '+' or '-': '{}'", fmt::streamed(*it), ex));
    }
 
    ++it;
    if (it == end) {
        throw std::invalid_argument(
            fmt::format("unexpected end of expression, expected ' ' or scope: '{}'", ex));
    }
 
    // Optional scope
    Scope scope;
    switch (*it) {
    case ' ':
        scope = Scope::Any;
        break;
    case 'e':
        scope = Scope::Eso;
        break;
    case 'v':
        scope = Scope::Value;
        break;
    case 'c':
        scope = Scope::Commentary;
        break;
    default:
        throw std::invalid_argument(
            fmt::format("invalid scope '{}', must be one of 'v' (value), 'e' (ESO hierarchical) or "
                        "'c' (commentary): '{}'",
                        fmt::streamed(*it),
                        ex));
    }
 
    // Advance past scope, if it was used.
    if (scope != Scope::Any) {
        ++it;
    }
    if (it == end) {
        throw std::invalid_argument(
            fmt::format("unexpected end of expression, expected pattern: '{}'", ex));
    }
 
    // Confirm whitespace
    if (*it != ' ') {
        throw std::invalid_argument(
            fmt::format("whitespace ' ' expected after scope, got '{}': ", *it, ex));
    }
 
    // Advance past whitespace
    ++it;
    if (it == end) {
        throw std::invalid_argument(
            fmt::format("unexpected end of expression, expected pattern: '{}'", ex));
    }
 
    // Pattern (remaining characters)
    std::string pattern(it, end);
    return {op, scope, pattern};
}
 
bool KeywordScopeMatch(fits::KeywordType kwtype, Scope scope) {
    switch (scope) {
    case Scope::Any:
        return true;
    case Scope::Value:
        return kwtype == fits::KeywordType::Value;
    case Scope::Eso:
        return kwtype == fits::KeywordType::Eso;
    case Scope::Commentary:
        return kwtype == fits::KeywordType::Commentary;
    };
    // Invalid scope
    return false;  // GCOVR_EXCL_LINE
}
 
/**
 * Determines if keyword match rule and if yes, whether it matches;
 *
 * @returns std::nullopt if keyword does not match.
 * @returns Include if keyword matches rule and should be included.
 * @returns Exclude if keyword matches rule and should be excluded.
 */
std::optional<Operator> KeywordMatch(fits::KeywordNameView kw, Rule const& rule) {
    // Test if scope matches
    if (!KeywordScopeMatch(kw.type, rule.scope)) {
        // Scope doesn't match
        return std::nullopt;
    }
 
    // Test if glob match name
    auto name = std::string(kw.name);
    auto match = fnmatch(rule.pattern.c_str(), name.c_str(), 0);
 
    if (match == 0) {
        return rule.op;
    } else if (match == FNM_NOMATCH) {
        return std::nullopt;  // no match
    } else {                  // GCOVR_EXCL_START
        // fnmatch seems to accept most strange input so have not been able to test this.
        throw std::invalid_argument(fmt::format("invalid fnmatch pattern '{}'", rule.pattern));
        // GCOVR_EXCL_STOP
    }
}
 
std::string RegexReplace(std::string_view str, std::regex const& re, char const* fmt) {
    std::string result;
    std::regex_replace(std::back_inserter(result), std::begin(str), std::end(str), re, fmt);
    return result;
}
 
}  // namespace detail
 
KeywordEx::KeywordEx(std::string_view rule) : m_rules(1u, detail::ParseEx(rule)) {
}
 
bool KeywordMatch(fits::KeywordVariant const& keyword, KeywordEx const& ex) {
    bool match = false;  // By default keywords don't match
    auto name = fits::GetKeywordName(keyword);
    for (auto const& rule : ex.GetRules()) {
        // optimization: Exclusive rules can be skipped until there's a match
        auto opt_match = detail::KeywordMatch(name, rule);
        if (opt_match) {
            match = (*opt_match) == detail::Operator::Include;
        }
    }
    return match;
}
 
fits::KeywordVariant
KeywordTransform(fits::KeywordVariant const& keyword, std::regex const& re, char const* fmt) {
    return std::visit(
        [&](auto const& kw) -> fits::KeywordVariant { return KeywordTransform(kw, re, fmt); },
        keyword);
}
 
fits::ValueKeyword
KeywordTransform(fits::ValueKeyword const& keyword, std::regex const& re, char const* fmt) {
    try {
        auto new_name = detail::RegexReplace(keyword.name, re, fmt);
        return fits::ValueKeyword(new_name, keyword.value, keyword.comment);
    } catch (...) {
        std::throw_with_nested(std::runtime_error(
            fmt::format("Keyword transform failed for keyword `{}` with transform format `{}`",
                        fmt::streamed(keyword),
                        fmt)));
    }
}
 
fits::EsoKeyword
KeywordTransform(fits::EsoKeyword const& keyword, std::regex const& re, char const* fmt) {
    try {
        auto new_name = detail::RegexReplace(keyword.name, re, fmt);
        return fits::EsoKeyword(new_name, keyword.value, keyword.comment);
    } catch (...) {
        std::throw_with_nested(std::runtime_error(
            fmt::format("Keyword transform failed for keyword `{}` with transform format `{}`",
                        fmt::streamed(keyword),
                        fmt)));
    }
}
 
fits::LiteralKeyword
KeywordTransform(fits::LiteralKeyword const& keyword, std::regex const& re, char const* fmt) {
    try {
        std::string new_name = detail::RegexReplace(keyword.GetName().name, re, fmt);
        auto components = keyword.GetComponents();
        components.name = new_name;
        auto new_kw = Format(components);
        if (new_kw.GetType() != keyword.GetType()) {
            throw std::runtime_error(
                fmt::format("Keyword transform mutated keyword into a different type. Before: {}, "
                            "after: {}. Before transformation: `{}`, after: `{}`",
                            fmt::streamed(keyword.GetType()),
                            fmt::streamed(new_kw.GetType()),
                            keyword.GetRecord(),
                            new_kw.GetRecord()));
        }
        if (new_kw.GetComponents().value != components.value) {
            throw std::runtime_error(fmt::format(
                "Keyword transform mutated keyword such that the value field was affected "
                " Before transformation: `{}`, after: `{}`",
                keyword.GetRecord(),
                new_kw.GetRecord()));
        }
        return new_kw;
    } catch (...) {
        std::throw_with_nested(std::runtime_error(
            fmt::format("Keyword transform failed for keyword `{}` with transform format `{}`",
                        keyword.GetRecord(),
                        fmt)));
    }
}
 
}  // namespace daq::dpm