FitsSchemaInputMapper.h

Go to the documentation of this file.

// -*- lsst-c++ -*-
#ifndef AFW_TABLE_IO_FitsSchemaInputMapper_h_INCLUDED
#define AFW_TABLE_IO_FitsSchemaInputMapper_h_INCLUDED
 
#include "lsst/afw/fits.h"
#include "lsst/afw/table/Schema.h"
#include "lsst/afw/table/io/InputArchive.h"
#include "lsst/afw/table/BaseRecord.h"
#include "lsst/afw/table/BaseColumnView.h"
 
namespace lsst {
namespace afw {
namespace table {
namespace io {

class FitsColumnReader {
public:
    FitsColumnReader() noexcept = default;
 
    // Neither copyable nor moveable.
    FitsColumnReader(FitsColumnReader const &) = delete;
    FitsColumnReader(FitsColumnReader &&) = delete;
    FitsColumnReader &operator=(FitsColumnReader const &) = delete;
    FitsColumnReader &operator=(FitsColumnReader &&) = delete;

    virtual void prepRead(std::size_t firstRow, std::size_t nRows, fits::Fits & fits) {}

    virtual void readCell(BaseRecord &record, std::size_t row, fits::Fits &fits,
                          std::shared_ptr<InputArchive> const &archive) const = 0;
 
    virtual ~FitsColumnReader() noexcept = default;
};
class FitsColumnReader {…};

struct FitsSchemaItem {
    int column;         // column number (0-indexed); -1 for Flag fields
    int bit;            // flag bit number (0-indexed); -1 for non-Flag fields
    std::string ttype;  // name of the field (from TTYPE keys)
    std::string tform;  // FITS column format code (from TFORM keys)
    std::string tccls;  // which field class to use (from our own TCCLS keys)
    std::string tunit;  // field units (from TUNIT keys)
    std::string doc;    // field docs (from comments on TTYPE keys)
 
    explicit FitsSchemaItem(int column_, int bit_) : column(column_), bit(bit_) {}
};
struct FitsSchemaItem {…};

class FitsSchemaInputMapper {
public:
    using Item = FitsSchemaItem;

    static std::size_t PREPPED_ROWS_FACTOR;

    FitsSchemaInputMapper(daf::base::PropertyList &metadata, bool stripMetadata);
 
    FitsSchemaInputMapper(FitsSchemaInputMapper const &);
    FitsSchemaInputMapper(FitsSchemaInputMapper &&);
    FitsSchemaInputMapper &operator=(FitsSchemaInputMapper const &);
    FitsSchemaInputMapper &operator=(FitsSchemaInputMapper &&);
    ~FitsSchemaInputMapper();

    void setArchive(std::shared_ptr<InputArchive> archive);

    bool readArchive(afw::fits::Fits &fits);

    bool hasArchive() const;

    Item const *find(std::string const &ttype) const;

    Item const *find(int column) const;

    void erase(Item const *item);

    void erase(std::string const &ttype);

    void erase(int column);

    void customize(std::unique_ptr<FitsColumnReader> reader);

    Schema finalize();

    void readRecord(BaseRecord &record, afw::fits::Fits &fits, std::size_t row);
 
private:
    class Impl;
    std::shared_ptr<Impl> _impl;
};
class FitsSchemaInputMapper {…};
}  // namespace io
}  // namespace table
}  // namespace afw
}  // namespace lsst
 
#endif  // !AFW_TABLE_IO_FitsSchemaInputMapper_h_INCLUDED