sources.hpp

Go to the documentation of this file.

/**
 * @file
 * @ingroup daq_dpm_merge
 * @copyright ESO - European Southern Observatory
 */
#ifndef DAQ_DPM_MERGE_SOURCES_HPP
#define DAQ_DPM_MERGE_SOURCES_HPP
#include <filesystem>
#include <memory>
#include <string>
#include <variant>
 
#include <nlohmann/json.hpp>
 
#include <daq/dpm/keywordRule.hpp>
#include <daq/fits/cfitsio.hpp>
#include <daq/fits/keyword.hpp>
 
namespace daq::dpm::merge {
 
namespace base {
/**
 * Base source
 */
class Source {
public:
    explicit Source(std::string name) noexcept;
    std::string const& GetName() const noexcept {
        return m_name;
    }
 
protected:
    std::string m_name;
};
 
class FitsFile {
public:
    /**
     * Open existing fits file
     *
     * @param path Path to file to open. If mode is ReadWrite it must be a regular file (not
     *             symlink).
     * @throw SourceNotFoundError if file cannot be found.
     * @throw std::invalid_argument for other errors
     */
    explicit FitsFile(std::filesystem::path path, fits::OpenMode mode);
    explicit FitsFile(std::filesystem::path path, fits::UniqueFitsFile file);
 
    /**
     * Get fits file pointer.
     *
     * @note This may be nullptr if executed with dry-run.
     */
    fitsfile* GetFitsFile() const noexcept {
        return m_fits.get();
    }
 
    /**
     * Get file system path associated with this file.
     */
    std::filesystem::path const& GetFilePath() const& noexcept {
        return m_path;
    }
 
    /**
     * Close fits file.
     *
     * @post GetFitsFile() == nullptr
     */
    void Close() {
        m_fits.reset();
    }
 
private:
    std::filesystem::path m_path;
    fits::UniqueFitsFile m_fits;
};
 
/**
 * Represents the keyword rules from the Data Product Specification.
 *
 * Currently only primary HDU keywords are supported, if this were to change this structure will
 * have to be generalized to support it (with possibly different implementations for FITS file
 * sources and JSON keywords).
 */
class KeywordRules {
public:
    KeywordRules(std::unique_ptr<KeywordRuleProcessor> keyword_rules);
    KeywordRuleProcessor const& GetKeywordRuleProcessor() const {
        return *m_processor;
    }
 
private:
    std::unique_ptr<KeywordRuleProcessor> m_processor;
};
 
}  // namespace base
 
/**
 * Source file not found.
 */
struct SourceNotFoundError : std::invalid_argument {
    SourceNotFoundError(char const* path);
};
 
/**
 * Target FITS file
 *
 * @ingroup daq_dpm_merge
 */
class TargetSource : private base::Source, private base::FitsFile, base::KeywordRules {
public:
    TargetSource(std::string name,
                 std::filesystem::path path,
                 std::unique_ptr<KeywordRuleProcessor> keyword_rules);
    /**
     * Used by unit tests and when executing as dry-run. Allows for @a file to be faked.
     */
    TargetSource(std::string name,
                 std::filesystem::path path,
                 std::unique_ptr<KeywordRuleProcessor> keyword_rules,
                 fits::UniqueFitsFile file);
    using FitsFile::Close;
    using FitsFile::GetFilePath;
    using FitsFile::GetFitsFile;
    using KeywordRules::GetKeywordRuleProcessor;
    using Source::GetName;
};
 
/**
 * Input FITS source file.
 *
 * @ingroup daq_dpm_merge
 */
class FitsFileSource : private base::Source, private base::FitsFile, base::KeywordRules {
public:
    FitsFileSource(std::string name,
                   std::filesystem::path path,
                   std::string origin,
                   std::unique_ptr<KeywordRuleProcessor> keyword_rules);
 
    using FitsFile::Close;
    using FitsFile::GetFilePath;
    using FitsFile::GetFitsFile;
    using KeywordRules::GetKeywordRuleProcessor;
    using Source::GetName;
 
private:
    /**
     * Path as provided in data product specification
     */
    std::string m_origin;
};
 
/**
 * Input FITS keywords.
 *
 * @ingroup daq_dpm_merge
 */
class FitsKeywordsSource : base::Source, base::KeywordRules {
public:
    FitsKeywordsSource(std::string name,
                       fits::KeywordVector keywords,
                       std::unique_ptr<KeywordRuleProcessor> keyword_rules) noexcept;
    using KeywordRules::GetKeywordRuleProcessor;
    using Source::GetName;
 
    fits::KeywordVector const& GetKeywords() const& noexcept {
        return m_keywords;
    }
 
    fits::KeywordVector& GetKeywords() & noexcept {
        return m_keywords;
    }
 
private:
    fits::KeywordVector m_keywords;
};
 
/**
 * Variant of the different supported source types.
 */
using SourceTypes = std::variant<FitsKeywordsSource, FitsFileSource>;
 
}  // namespace daq::dpm::merge
 
#endif  // #ifndef DAQ_DPM_MERGE_SOURCES_HPP