FitsWriter.h

Go to the documentation of this file.

// -*- lsst-c++ -*-
#ifndef AFW_TABLE_IO_FitsWriter_h_INCLUDED
#define AFW_TABLE_IO_FitsWriter_h_INCLUDED
 
#include <set>
 
#include "lsst/base.h"
#include "lsst/pex/exceptions.h"
#include "lsst/afw/table/BaseTable.h"
#include "lsst/afw/fits.h"
 
namespace lsst {
namespace afw {
namespace table {
namespace io {
 
class FitsWriter {
public:
    typedef afw::fits::Fits Fits;
 
    template <typename OutputT, typename ContainerT>
    static void apply(OutputT& output, std::string const& mode, ContainerT const& container, int flags) {
        Fits fits(output, mode, Fits::AUTO_CLOSE | Fits::AUTO_CHECK);
        apply(fits, container, flags);
    }
 
    template <typename ContainerT>
    static void apply(Fits& fits, ContainerT const& container, int flags) {
        std::shared_ptr<FitsWriter> writer =
                std::static_pointer_cast<BaseTable const>(container.getTable())->makeFitsWriter(&fits, flags);
        writer->write(container);
    }
 
    template <typename ContainerT>
    void write(ContainerT const& container) {
        std::set<std::shared_ptr<BaseTable const>> tables;
        for (typename ContainerT::const_iterator i = container.begin(); i != container.end(); ++i) {
            if (i->getTable() != container.getTable()) tables.insert(i->getTable());
        }
        for (std::set<std::shared_ptr<BaseTable const>>::iterator j = tables.begin(); j != tables.end();
             ++j) {
            if ((**j).getSchema().compare(container.getTable()->getSchema(), Schema::IDENTICAL) !=
                Schema::IDENTICAL) {
                throw LSST_EXCEPT(pex::exceptions::LogicError,
                                  "Cannot save Catalog with heterogenous schemas");
            }
        }
        _writeTable(container.getTable(), container.size());
        for (typename ContainerT::const_iterator i = container.begin(); i != container.end(); ++i) {
            _writeRecord(*i);
        }
        _finish();
    }
 
    explicit FitsWriter(Fits* fits, int flags) : _fits(fits), _flags(flags) {}
 
    FitsWriter(FitsWriter const&) = default;
    FitsWriter(FitsWriter&&) = default;
    FitsWriter& operator=(FitsWriter const&) = default;
    FitsWriter& operator=(FitsWriter&&) = default;
    virtual ~FitsWriter() = default;
 
protected:
    virtual void _writeTable(std::shared_ptr<BaseTable const> const& table, std::size_t nRows);
 
    virtual void _writeRecord(BaseRecord const& source);
 
    virtual void _finish() {}
 
    Fits* _fits;       // wrapped cfitsio pointer
    int _flags;        // subclass-defined flags to control writing
    std::size_t _row;  // which row we're currently processing
 
private:
    struct ProcessRecords;
 
    std::shared_ptr<ProcessRecords> _processor;  // a private Schema::forEach functor that write records
};
}  // namespace io
}  // namespace table
}  // namespace afw
}  // namespace lsst
 
#endif  // !AFW_TABLE_IO_FitsWriter_h_INCLUDED