dictKeywordFormatter.cpp

Go to the documentation of this file.

/**
 * @file
 * @copyright
 * (c) Copyright ESO 2024
 * All Rights Reserved
 * ESO (eso.org) is an Intergovernmental Organisation, and therefore special legal conditions apply.
 */
#include "dictKeywordFormatter.hpp"
 
#include <algorithm>
#include <charconv>
#include <cstdint>
 
#include <boost/algorithm/string/join.hpp>
 
namespace daq {
using namespace daq::fits;
 
namespace {
 
template <class T>
constexpr char const* TypeStr() noexcept;
 
template <>
constexpr char const* TypeStr<std::uint64_t>() noexcept {
    return "uint64";
}
template <>
constexpr char const* TypeStr<std::int64_t>() noexcept {
    return "int64";
}
 
template <>
constexpr char const* TypeStr<double>() noexcept {
    return "double";
}
 
template <>
constexpr char const* TypeStr<bool>() noexcept {
    return "bool";
}
 
template <>
constexpr char const* TypeStr<std::string>() noexcept {
    return "string";
}
 
template <class T>
constexpr auto DitDataType() noexcept -> core::dit::did::DataType;
 
template <>
constexpr auto DitDataType<std::uint64_t>() noexcept -> core::dit::did::DataType {
    return core::dit::did::DataType::INTEGER;
}
 
template <>
constexpr auto DitDataType<std::int64_t>() noexcept -> core::dit::did::DataType {
    return core::dit::did::DataType::INTEGER;
}
 
template <>
constexpr auto DitDataType<std::string>() noexcept -> core::dit::did::DataType {
    return core::dit::did::DataType::STRING;
}
 
template <>
constexpr auto DitDataType<bool>() noexcept -> core::dit::did::DataType {
    return core::dit::did::DataType::BOOL;
}
 
/**
 * FITS strings must be quoted with '' and any ' within must be escaped as `''`.
 */
void ValidateString(std::string_view name, std::string_view value) {
    auto bad = [&](std::string_view reason) {
        throw InvalidKeyword(
            name, fmt::format("validating string value `{}` failed - {}", value, reason));
    };
    if (value.size() < 2u) {
        bad("string not enclosed with `'`");
    }
    if (*value.begin() != '\'') {
        bad("must begin with '");
    }
    if (*(value.end() - 1) != '\'') {
        bad("must end with '");
    }
    // Check the content of {string} string within '{string}'
    bool unescaped_quote = false;
    for (auto c : value.substr(1, value.size() - 2)) {
        if (unescaped_quote && c != '\'') {
            bad("quote `'` must be escaped as `''`");
        }
        if (c == '\'') {
            unescaped_quote = !unescaped_quote;
        } else if (c < ' ' || c > '~') {
            // Invalid character
            bad(fmt::format("invalid character `{}`", c));
        }
    }
 
    if (unescaped_quote) {
        bad("quote `'` must be escaped as `''`");
    }
}
 
void ValidateInteger(std::string_view name, std::string_view value) {
    long int_value = 0;
    auto [ptr, ec] = std::from_chars(value.begin(), value.end(), int_value);
    if (ec != std::errc{}) {
        // Could not parse full range or value is out of range
        throw InvalidKeyword(name,
                             fmt::format("parsing base-10 integer value `{}` failed with {}",
                                         value,
                                         std::make_error_code(ec).message()));
    } else if (ptr != value.end()) {
        throw InvalidKeyword(
            name,
            fmt::format("parsing base-10 integer value `{}` failed as not all characters was "
                        "converted",
                        value));
    }
}
 
auto FormatFloat(double value,
                 std::string_view format,
                 std::array<char, constants::RECORD_LENGTH>& buffer) -> std::string_view {
    std::string fmt = std::string("%") + std::string(format);
    auto sz = snprintf(buffer.data(), buffer.size(), fmt.c_str(), value);
    return std::string_view(buffer.data(), sz);
}
 
auto ReformatFloat(std::string_view name,
                   std::string_view value,
                   std::string_view format,
                   std::array<char, constants::RECORD_LENGTH>& buffer) -> std::string_view {
    double float_value = 0.0;
    auto [ptr, ec] = std::from_chars(value.begin(), value.end(), float_value);
    if (ec != std::errc{}) {
        // Could not parse full range or value is out of range
        throw InvalidKeyword(name,
                             fmt::format("parsing floating point value `{}` failed with {}",
                                         value,
                                         std::make_error_code(ec).message()));
    } else if (ptr != value.end()) {
        throw InvalidKeyword(
            name,
            fmt::format("parsing floating point value `{}` failed as not all characters was "
                        "converted",
                        value));
    }
    if (format.empty()) {
        return {};
    }
    // Got a valid floating point value -> format it.
    return FormatFloat(float_value, format, buffer);
}
 
auto Format(LiteralKeyword const& keyword, core::dit::did::Record const& record) -> LiteralKeyword {
    using core::dit::did::DataType;
    std::string_view logical_name = keyword.GetName().name;
    std::array<char, constants::RECORD_LENGTH> value_buf;
    auto const components = keyword.GetComponents();
    auto new_components = components;
 
    // Validate data type and reformat as necessary
    switch (record.GetDataType()) {
    case DataType::DOUBLE:
        if (auto new_value =
                ReformatFloat(logical_name, components.value, record.GetFormat(), value_buf);
            !new_value.empty()) {
            new_components.value = new_value;
        }
        break;
    case DataType::BOOL:
        // Must be `T` or `F`
        if (components.value != "T" && components.value != "F") {
            throw InvalidKeyword(
                logical_name,
                fmt::format("dictionary specifies value to be boolean but `{}` is not `T` or `F`",
                            components.value));
        }
        break;
    case DataType::INTEGER:
        ValidateInteger(logical_name, components.value);
    case DataType::STRING:
        // Must be `'[^']*'`
        ValidateString(logical_name, components.value);
        break;
 
    case DataType::ALL:  // GCOVR_EXCL_START
        [[fallthrough]];
    default:
        // These are not really expected but if provided we won't do anything with it.
        break;
        // GCOVR_EXCL_STOP
    };
 
    // Add comment if none is provided
    if (keyword.GetComponents().comment.empty() && !record.GetComment().empty()) {
        new_components.comment = record.GetComment();
    }
 
    // Formatting also include insignificant whitespaces so we cannot simply compare the components
    return Format(new_components);
}
 
auto CheckedFormat(KeywordNameView name,
                   double value,
                   std::optional<std::string> const& opt_comment,
                   core::dit::did::Record const& record) -> LiteralKeyword {
    namespace did = core::dit::did;
    if (record.GetDataType() != did::DataType::DOUBLE) {
        throw InvalidKeyword(name.name,
                             fmt::format("dictionary specifies value to be {} but value is {}",
                                         DataTypeToStr(record.GetDataType()),
                                         TypeStr<decltype(value)>()));
    }
    auto comment = opt_comment.value_or(record.GetComment());
    if (auto const& fmt = record.GetFormat(); !fmt.empty()) {
        // Use user-provided format
        std::array<char, constants::RECORD_LENGTH> buf;
        return UntypedFormat(name, FormatFloat(value, fmt, buf), comment);
    } else {
        // No custom format, just use default.
        return UntypedFormat(name, FormatFitsValue(name, value), comment);
    }
}
 
template <class Trait>
auto Format(BasicKeyword<Trait> const& keyword, core::dit::did::Record const& record)
    -> LiteralKeyword {
    // Handle special case of double reformatting
    return std::visit(
        [&](auto& value) -> LiteralKeyword {
            using T = std::decay_t<decltype(value)>;
            // In
            if constexpr (std::is_same_v<T, double>) {
                return CheckedFormat(keyword.GetName(), value, keyword.comment, record);
            } else {
                if (DitDataType<T>() != record.GetDataType()) {
                    throw InvalidKeyword(
                        keyword.GetName().name,
                        fmt::format("dictionary specifies value to be {} but value is {}",
                                    core::dit::did::DataTypeToStr(record.GetDataType()),
                                    TypeStr<T>()));
                }
                // Use default formatting
                if (!keyword.comment && !record.GetComment().empty()) {
                    auto copy = keyword;
                    copy.comment = record.GetComment();
                    return daq::fits::Format(copy);
                } else {
                    return daq::fits::Format(keyword);
                }
            }
        },
        keyword.value);
}
 
}  // namespace
 
void DictKeywordFormatter::Load(std::vector<std::string> const& dictionaries) try {
    std::for_each(dictionaries.begin(), dictionaries.end(), [&](std::string const& path) {
        m_did.Load(path);
    });
    std::copy(dictionaries.begin(), dictionaries.end(), std::back_inserter(m_dictionaries));
} catch (...) {
    char const* cfgpath = std::getenv("CFGPATH");
    if (cfgpath == nullptr) {
        cfgpath = "{unset}";
    }
    std::throw_with_nested(
        std::runtime_error(fmt::format("Failed to load dictionaries using $CFGPATH={}", cfgpath)));
}
 
auto DictKeywordFormatter::Format(KeywordVariant const& keyword) const -> LiteralKeyword {
    auto name = GetKeywordName(keyword);
    core::dit::did::Record record;
    if (!m_did.LookUp(
            std::string(name.name), record, true /* allow index subst */, false /* throw */)) {
        throw UnknownKeyword(name.name, m_dictionaries);
    }
    return daq::Format(keyword, record);
}
auto DictKeywordFormatter::GetDictionaries() const noexcept -> std::vector<std::string> const& {
    return m_dictionaries;
}
auto DictKeywordFormatter::GetDictionariesNames() const -> std::string {
    return boost::algorithm::join(m_dictionaries, ", ");
}
 
auto Format(KeywordVariant const& keyword, core::dit::did::Record const& record) -> LiteralKeyword {
    return std::visit([&](auto& kw) -> LiteralKeyword { return Format(kw, record); }, keyword);
}
}  // namespace daq