Persistable.h

Go to the documentation of this file.

// -*- lsst-c++ -*-
#ifndef AFW_TABLE_IO_Persistable_h_INCLUDED
#define AFW_TABLE_IO_Persistable_h_INCLUDED
 
#include <climits>
#include "lsst/base.h"
#include "lsst/pex/exceptions.h"
#include "lsst/afw/fitsDefaults.h"
 
namespace lsst {
namespace afw {
 
namespace fits {
 
class Fits;
class MemFileManager;
 
}  // namespace fits
 
namespace table {
namespace io {
 
class InputArchive;
class OutputArchive;
class OutputArchiveHandle;
class CatalogVector;

LSST_EXCEPTION_TYPE(PersistenceError, lsst::pex::exceptions::IoError, lsst::afw::table::io::PersistenceError)
 

LSST_EXCEPTION_TYPE(MalformedArchiveError, lsst::afw::table::io::PersistenceError,
                    lsst::afw::table::io::MalformedArchiveError)
 

#define LSST_ARCHIVE_ASSERT(EXPR) \
    if (!(EXPR))                  \
    throw LSST_EXCEPT(lsst::afw::table::io::MalformedArchiveError, "Archive assertion failed: " #EXPR)

class Persistable {
public:
    void writeFits(std::string const& fileName, std::string const& mode = "w") const;

    void writeFits(fits::MemFileManager& manager, std::string const& mode = "w") const;

    void writeFits(fits::Fits& fitsfile) const;

    virtual bool isPersistable() const noexcept { return false; }
 
    virtual ~Persistable() noexcept = default;
 
protected:
    // convenient for derived classes not in afw::table::io
    using OutputArchiveHandle = io::OutputArchiveHandle;

    virtual std::string getPersistenceName() const;

    virtual std::string getPythonModule() const;

    virtual void write(OutputArchiveHandle& handle) const;
 
    Persistable() noexcept = default;
 
    Persistable(Persistable const& other) noexcept = default;
    Persistable(Persistable&& other) noexcept = default;
 
    Persistable& operator=(Persistable const& other) noexcept = default;
    Persistable& operator=(Persistable&& other) noexcept = default;
 
private:
    friend class io::OutputArchive;
    friend class io::InputArchive;
 
    template <typename T>
    friend class PersistableFacade;
 
    static std::shared_ptr<Persistable> _readFits(std::string const& fileName, int hdu = fits::DEFAULT_HDU);
 
    static std::shared_ptr<Persistable> _readFits(fits::MemFileManager& manager, int hdu = fits::DEFAULT_HDU);
 
    static std::shared_ptr<Persistable> _readFits(fits::Fits& fitsfile);
};

template <typename T>
class PersistableFacade {
public:
    static std::shared_ptr<T> readFits(fits::Fits& fitsfile) {
        return dynamicCast(Persistable::_readFits(fitsfile));
    }

    static std::shared_ptr<T> readFits(std::string const& fileName, int hdu = fits::DEFAULT_HDU) {
        return dynamicCast(Persistable::_readFits(fileName, hdu));
    }

    static std::shared_ptr<T> readFits(fits::MemFileManager& manager, int hdu = fits::DEFAULT_HDU) {
        return dynamicCast(Persistable::_readFits(manager, hdu));
    }

    static std::shared_ptr<T> dynamicCast(std::shared_ptr<Persistable> const &ptr);
};

class PersistableFactory {
protected:
    using InputArchive = io::InputArchive;  // convenient for derived classes not in afw::table::io
    using CatalogVector = io::CatalogVector;
 
public:
    explicit PersistableFactory(std::string const& name);

    virtual std::shared_ptr<Persistable> read(InputArchive const& archive,
                                              CatalogVector const& catalogs) const = 0;

    static PersistableFactory const& lookup(std::string const& name, std::string const& module = "");
 
    virtual ~PersistableFactory() noexcept = default;
 
    // No copying
    PersistableFactory(const PersistableFactory&) = delete;
    PersistableFactory& operator=(const PersistableFactory&) = delete;
 
    // No moving
    PersistableFactory(PersistableFactory&&) = delete;
    PersistableFactory& operator=(PersistableFactory&&) = delete;
};
}  // namespace io
}  // namespace table
}  // namespace afw
}  // namespace lsst
 
#endif  // !AFW_TABLE_IO_Persistable_h_INCLUDED