BaseTable.h

Go to the documentation of this file.

// -*- lsst-c++ -*-
#ifndef AFW_TABLE_BaseTable_h_INCLUDED
#define AFW_TABLE_BaseTable_h_INCLUDED
#include <memory>
 
#include "lsst/base.h"
#include "ndarray/Manager.h"
#include "lsst/afw/table/fwd.h"
#include "lsst/afw/table/Schema.h"
 
namespace lsst {
namespace afw {
 
namespace fits {
 
class Fits;
 
}  // namespace fits
 
namespace table {
 
namespace detail {

struct RecordData {
    void* data;
    std::shared_ptr<BaseTable> table;
    ndarray::Manager::Ptr manager;
};
 
}  // namespace detail

class BaseTable : public std::enable_shared_from_this<BaseTable> {
public:
    using Record = BaseRecord;

    using ColumnView = BaseColumnView;

    using Catalog = CatalogT<Record>;

    using ConstCatalog = CatalogT<const Record>;

    static int nRecordsPerBlock;

    std::shared_ptr<daf::base::PropertyList> getMetadata() const { return _metadata; }

    void setMetadata(std::shared_ptr<daf::base::PropertyList> const& metadata) { _metadata = metadata; }

    std::shared_ptr<daf::base::PropertyList> popMetadata() {
        std::shared_ptr<daf::base::PropertyList> tmp;
        _metadata.swap(tmp);
        return tmp;
    }

    std::shared_ptr<BaseTable> clone() const { return _clone(); }

    std::shared_ptr<BaseRecord> makeRecord() { return _makeRecord(); }

    std::shared_ptr<BaseRecord> copyRecord(BaseRecord const& input);

    std::shared_ptr<BaseRecord> copyRecord(BaseRecord const& input, SchemaMapper const& mapper);

    Schema getSchema() const { return _schema; }

    void preallocate(std::size_t nRecords);

    std::size_t getBufferSize() const;

    static std::shared_ptr<BaseTable> make(Schema const& schema);

    static Schema makeMinimalSchema();
 
    // Tables are not assignable to prevent type slicing.
    BaseTable& operator=(BaseTable const& other) = delete;
    BaseTable& operator=(BaseTable&& other) = delete;
 
    virtual ~BaseTable();
 
protected:
    // n.b. this is implemented in BaseRecord.h, as it requires the BaseRecord
    // definition, and must go in a header.
    template <typename RecordT, typename... Args>
    std::shared_ptr<RecordT> constructRecord(Args&&... args);
 
    virtual void handleAliasChange(std::string const& alias) {}

    virtual std::shared_ptr<BaseTable> _clone() const;

    virtual std::shared_ptr<BaseRecord> _makeRecord();

    explicit BaseTable(Schema const& schema, std::shared_ptr<daf::base::PropertyList> metadata = nullptr);
 
    BaseTable(BaseTable const& other);
    BaseTable(BaseTable&& other) = delete;
 
private:
    friend class BaseRecord;
    friend class io::FitsWriter;
    friend class AliasMap;
 
    // Obtain raw data pointers and their managing objects for a new record.
    detail::RecordData _makeNewRecordData();
 
    /*
     *  Called by BaseRecord dtor to notify the table when it is about to be destroyed.
     *
     *  This could allow the table to reclaim that space, but that requires more bookkeeping than
     *  it's presently worth unless this was the most recently allocated record.
     *
     *  The motivation for attempting to reclaim even some memory is not because we're paranoid
     *  about using every last bit of allocated memory efficiently - it's so we can keep
     *  records contiguous as much as possible to allow ColumnView to be used.
     */
    void _destroy(BaseRecord& record);
 
    // Return a writer object that knows how to save in FITS format.  See also FitsWriter.
    virtual std::shared_ptr<io::FitsWriter> makeFitsWriter(fits::Fits* fitsfile, int flags) const;
 
    // All these are definitely private, not protected - we don't want derived classes mucking with them.
    Schema _schema;                                      // schema that defines the table's fields
    ndarray::Manager::Ptr _manager;                      // current memory block to use for new records
    std::shared_ptr<daf::base::PropertyList> _metadata;  // flexible metadata; may be null
};
 
}  // namespace table
}  // namespace afw
}  // namespace lsst
 
#endif  // !AFW_TABLE_BaseTable_h_INCLUDED