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
    typedef io::OutputArchiveHandle 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:
    typedef io::InputArchive InputArchive;  // convenient for derived classes not in afw::table::io
    typedef io::CatalogVector 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