OutputArchive.h

Go to the documentation of this file.

// -*- lsst-c++ -*-
#ifndef AFW_TABLE_IO_OutputArchive_h_INCLUDED
#define AFW_TABLE_IO_OutputArchive_h_INCLUDED
 
#include "lsst/base.h"
#include "lsst/afw/table/io/Persistable.h"
 
namespace lsst {
namespace afw {
namespace table {
 
class Schema;
class BaseRecord;
template <typename RecordT>
class CatalogT;
using BaseCatalog = CatalogT<BaseRecord>;
 
namespace io {
 
class Persistable;
class OutputArchiveHandle;

class OutputArchive final {
public:
    friend class OutputArchiveHandle;

    OutputArchive();

    OutputArchive(OutputArchive const& other);
    OutputArchive(OutputArchive&& other);

    OutputArchive& operator=(OutputArchive const& other);
    OutputArchive& operator=(OutputArchive&& other);
 
    // (trivial) destructor must be defined in the source for pimpl idiom.
    ~OutputArchive();


    int put(std::shared_ptr<Persistable const> obj, bool permissive = false);
    int put(Persistable const * obj, bool permissive = false);
    int put(Persistable const & obj, bool permissive = false) { return put(&obj, permissive); }

    BaseCatalog const& getIndexCatalog() const;

    BaseCatalog const& getCatalog(int n) const;

    std::size_t countCatalogs() const;

    void writeFits(fits::Fits& fitsfile) const;
 
private:
    class Impl;
 
    std::shared_ptr<Impl> _impl;
};
class OutputArchive final {…};

class OutputArchiveHandle final {
public:
    BaseCatalog makeCatalog(Schema const& schema);

    void saveEmpty();

    void saveCatalog(BaseCatalog const& catalog);

    int put(Persistable const* obj, bool permissive = false);
    int put(std::shared_ptr<Persistable const> obj, bool permissive = false);
    int put(Persistable const & obj, bool permissive = false) { return put(&obj, permissive); }
 
    ~OutputArchiveHandle();
 
    // No copying
    OutputArchiveHandle(const OutputArchiveHandle&) = delete;
    OutputArchiveHandle& operator=(const OutputArchiveHandle&) = delete;
 
    // No moving
    OutputArchiveHandle(OutputArchiveHandle&&) = delete;
    OutputArchiveHandle& operator=(OutputArchiveHandle&&) = delete;
 
private:
    friend class OutputArchive::Impl;
 
    OutputArchiveHandle(int id, std::string const& name, std::string const& module,
                        std::shared_ptr<OutputArchive::Impl> impl);
 
    int _id;
    int _catPersistable;
    std::string _name;
    std::string _module;
    std::shared_ptr<OutputArchive::Impl> _impl;
};
class OutputArchiveHandle final {…};
}  // namespace io
}  // namespace table
}  // namespace afw
}  // namespace lsst
 
#endif  // !AFW_TABLE_IO_OutputArchive_h_INCLUDED