keyword.cpp

Go to the documentation of this file.

/**
 * @file
 * @ingroup daq_ocm_libfits
 * @copyright 2021 ESO - European Southern Observatory
 *
 * @brief Definition of contents from fits/keyword.hpp
 */
#include <daq/fits/keyword.hpp>
#include <algorithm>
#include <ostream>
 
namespace {
template <class>
inline constexpr bool always_false_v = false;  // NOLINT
template <class T>
char const* TypeStr() noexcept;
template <>
char const* TypeStr<uint64_t>() noexcept {
    return "uint64_t";
}
template <>
char const* TypeStr<int64_t>() noexcept {
    return "int64_t";
}
template <>
char const* TypeStr<double>() noexcept {
    return "double";
}
 
}  // namespace
 
namespace daq::fits {
// Instantiate the different variants
template struct BasicKeyword<ValueKeywordTraits>;
template struct BasicKeyword<EsoKeywordTraits>;
 
template std::ostream&
operator<<<EsoKeywordTraits>(std::ostream& os, BasicKeyword<EsoKeywordTraits> const& kw);
 
template std::ostream&
operator<<<ValueKeywordTraits>(std::ostream& os, BasicKeyword<ValueKeywordTraits> const& kw);
 
template <class Trait>
BasicKeyword<Trait>::BasicKeyword(std::string name_arg,
                                  char const* string_value,
                                  std::optional<std::string> comment_arg)
    : name(std::move(name_arg)), value(std::string(string_value)), comment(std::move(comment_arg)) {
}
 
template <class Trait>
BasicKeyword<Trait>::BasicKeyword(std::string name_arg,
                                  ValueType value_arg,
                                  std::optional<std::string> comment_arg) noexcept
    : name(std::move(name_arg)), value(std::move(value_arg)), comment(std::move(comment_arg)) {
}
 
template <class Trait>
bool BasicKeyword<Trait>::operator==(BasicKeyword<Trait> const& rhs) const noexcept {
    return name == rhs.name && value == rhs.value && comment == rhs.comment;
}
 
template <class Trait>
bool BasicKeyword<Trait>::operator!=(BasicKeyword<Trait> const& rhs) const noexcept {
    return !(*this == rhs);
}
 
template <class Trait>
bool BasicKeyword<Trait>::operator<(BasicKeyword<Trait> const& rhs) const noexcept {
    return name < rhs.name;
}
 
 
bool NameEquals(KeywordVariant const& lhs, KeywordVariant const& rhs) noexcept {
   if (lhs.index() != rhs.index()) {
       return false;
   }
   return std::visit(
        [&](auto const& lhs, auto const& rhs) noexcept -> bool {
            return lhs.name == rhs.name;
        },
        lhs, rhs);
}
 
std::ostream& operator<<(std::ostream& os, BasicKeywordBase::ValueType const& kw) {
    std::visit(
        [&](auto const& var) mutable {
            using T = std::decay_t<decltype(var)>;
            if constexpr (std::is_same_v<T, std::string>) {
                os << "(str)'" << var << "'";
            } else if constexpr (std::is_same_v<T, bool>) {
                os << "(bool)" << (var ? "true" : "false");
            } else {
                os << "(" << TypeStr<T>() << ")" << var;
            }
        },
        kw);
    return os;
}
 
template <class Trait>
std::ostream& operator<<(std::ostream& os, BasicKeyword<Trait> const& kw) {
    os << "name='" << kw.name << "', value=" << kw.value << ", comment=";
    if (kw.comment) {
        os << "'" << *kw.comment << "'";
    } else {
        os << "n/a";
    }
    return os;
}
 
std::ostream& operator<<(std::ostream& os, KeywordVariant const& kw) {
    std::visit(
        [&](auto const& var) mutable {
            os << var;
        },
        kw);
    return os;
}
 
void UpdateKeywords(KeywordVector& to, KeywordVector const& from) {
    for (auto const& kw : from) {
        if (auto it = std::find_if(
                to.begin(), to.end(), [&](auto const& val) { return NameEquals(val, kw); });
            it != to.end()) {
            // Replace existing keyword with same name (and type)
            *it = kw;
        } else {
            // Otherwise append
            to.emplace_back(kw);
        }
    }
}
 
}  // namespace daq::fits