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