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 "boost/noncopyable.hpp"

#include "lsst/base.h"
#include "lsst/pex/exceptions.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;

#ifndef SWIG // only expose the higher-level interfaces to Python

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

#endif // !SWIG

    virtual bool isPersistable() const { return false; }

    virtual ~Persistable() {}

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() {}

    Persistable(Persistable const & other) {}

    void operator=(Persistable const & other) {}

private:

    friend class io::OutputArchive;
    friend class io::InputArchive;

    template <typename T> friend class PersistableFacade;

    static PTR(Persistable) _readFits(std::string const & fileName, int hdu=0);

    static PTR(Persistable) _readFits(fits::MemFileManager & manager, int hdu=0);

    static PTR(Persistable) _readFits(fits::Fits & fitsfile);

};

template <typename T>
class PersistableFacade {
public:

#ifndef SWIG

    static PTR(T) readFits(fits::Fits & fitsfile) {
        return boost::dynamic_pointer_cast<T>(Persistable::_readFits(fitsfile));
    }

#endif // !SWIG

    static PTR(T) readFits(std::string const & fileName, int hdu=0) {
        return boost::dynamic_pointer_cast<T>(Persistable::_readFits(fileName, hdu));
    }

    static PTR(T) readFits(fits::MemFileManager & manager, int hdu=0) {
        return boost::dynamic_pointer_cast<T>(Persistable::_readFits(manager, hdu));
    }

};

#ifndef SWIG

class PersistableFactory : private boost::noncopyable {
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 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() {}
};

#endif // !SWIG

}}}} // namespace lsst::afw::table::io

#endif // !AFW_TABLE_IO_Persistable_h_INCLUDED