sources.cpp

Go to the documentation of this file.

/**
 * @file
 * @ingroup daq_dpm_merge
 * @copyright ESO - European Southern Observatory
 */
#include "sources.hpp"
 
#include <fmt/format.h>
 
namespace daq::dpm::merge {
 
namespace base {
 
KeywordRules::KeywordRules(std::optional<KeywordRuleProcessor::DefaultRule> const& initial,
                           std::unique_ptr<KeywordRuleProcessor> keyword_rules)
    : m_initial(initial), m_processor(std::move(keyword_rules)) {
}
 
Source::Source(std::string name) noexcept : m_name(std::move(name)) {
}
 
FitsFile::FitsFile(std::filesystem::path path, fits::OpenMode mode)
    : m_path(std::move(path)), m_fits(nullptr, fits::DefaultClose) {
    auto entry = std::filesystem::directory_entry(m_path);
    if (!entry.exists()) {
        throw SourceNotFoundError(m_path.c_str());
    }
    if (mode == fits::OpenMode::ReadWrite && !entry.is_regular_file()) {
        throw std::invalid_argument(
            fmt::format("source path must be a regular file: '{}'", m_path.c_str()));
    }
    m_fits = fits::Open(m_path.c_str(), mode);
}
FitsFile::FitsFile(std::filesystem::path path, fits::UniqueFitsFile file)
    : m_path(std::move(path)), m_fits(std::move(file)) {
}
 
}  // namespace base
 
SourceNotFoundError::SourceNotFoundError(char const* path)
    : std::invalid_argument(fmt::format("source path not found: '{}' ", path).c_str()) {
}
 
TargetSource::TargetSource(std::string name,
                           std::filesystem::path path,
                           std::optional<KeywordRuleProcessor::DefaultRule> const& initial,
                           std::unique_ptr<KeywordRuleProcessor> keyword_rules)
    : base::Source(std::move(name))
    , base::FitsFile(std::move(path), fits::OpenMode::ReadWrite)
    , base::KeywordRules(initial, std::move(keyword_rules)) {
}
 
TargetSource::TargetSource(std::string name,
                           std::filesystem::path path,
                           std::optional<KeywordRuleProcessor::DefaultRule> const& initial,
                           std::unique_ptr<KeywordRuleProcessor> keyword_rules,
                           fits::UniqueFitsFile file)
    : base::Source(std::move(name))
    , base::FitsFile(std::move(path), std::move(file))
    , base::KeywordRules(initial, std::move(keyword_rules)) {
}
 
FitsFileSource::FitsFileSource(std::string name,
                               std::filesystem::path path,
                               std::string location,
                               std::optional<KeywordRuleProcessor::DefaultRule> const& initial,
                               std::unique_ptr<KeywordRuleProcessor> keyword_rules,
                               bool alert_unmergeable)
    : base::Source(std::move(name))
    , base::FitsFile(std::move(path), fits::OpenMode::ReadOnly)
    , base::KeywordRules(initial, std::move(keyword_rules))
    , m_location(std::move(location))
    , m_alert_unmergeable(alert_unmergeable) {
}
 
FitsFileSource::FitsFileSource(std::string name,
                               std::filesystem::path path,
                               std::string location,
                               std::optional<KeywordRuleProcessor::DefaultRule> const& initial,
                               std::unique_ptr<KeywordRuleProcessor> keyword_rules,
                               bool alert_unmergeable,
                               fits::UniqueFitsFile file)
    : base::Source(std::move(name))
    , base::FitsFile(std::move(path), std::move(file))
    , base::KeywordRules(initial, std::move(keyword_rules))
    , m_location(std::move(location))
    , m_alert_unmergeable(alert_unmergeable) {
}
 
FitsKeywordsSource::FitsKeywordsSource(
    std::string name,
    fits::KeywordVector keywords,
    std::optional<KeywordRuleProcessor::DefaultRule> const& initial,
    std::unique_ptr<KeywordRuleProcessor> keyword_rules) noexcept
    : base::Source(std::move(name))
    , base::KeywordRules(initial, std::move(keyword_rules))
    , m_keywords(std::move(keywords)) {
}
 
}  // namespace daq::dpm::merge