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) {
        PTR(FitsWriter) writer
            = boost::static_pointer_cast<BaseTable const>(container.getTable())->makeFitsWriter(&fits, flags);
        writer->write(container);
    }

    template <typename ContainerT>
    void write(ContainerT const & container) {
        std::set<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<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) {}

protected:

    virtual void _writeTable(CONST_PTR(BaseTable) 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;


    PTR(ProcessRecords) _processor; // a private Schema::forEach functor that write records

};

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

#endif // !AFW_TABLE_IO_FitsWriter_h_INCLUDED