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 "lsst/daf/base/Citizen.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 {

class BaseTable : public std::enable_shared_from_this<BaseTable>, public daf::base::Citizen {
public:
    typedef BaseRecord Record;

    typedef BaseColumnView ColumnView;

    typedef CatalogT<Record> Catalog;

    typedef CatalogT<Record const> ConstCatalog;

    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);

    // Tables are not assignable to prevent type slicing.
    BaseTable& operator=(BaseTable const& other) = delete;
    BaseTable& operator=(BaseTable&& other) = delete;

    virtual ~BaseTable();

protected:
    template <typename Derived>
    std::shared_ptr<Derived> getSelf() {
        return std::static_pointer_cast<Derived>(shared_from_this());
    }

    template <typename Derived>
    std::shared_ptr<Derived const> getSelf() const {
        return std::static_pointer_cast<Derived const>(shared_from_this());
    }

    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);

    BaseTable(BaseTable const& other)
            : daf::base::Citizen(other), _schema(other._schema), _metadata(other._metadata) {
        if (_metadata) _metadata = std::static_pointer_cast<daf::base::PropertyList>(_metadata->deepCopy());
    }
    // Delegate to copy-constructor for backwards compatibility
    BaseTable(BaseTable&& other) : BaseTable(other) {}

private:
    friend class BaseRecord;
    friend class io::FitsWriter;
    friend class AliasMap;

    // Called by BaseRecord ctor to fill in its _data, _table, and _manager members.
    void _initialize(BaseRecord& record);

    /*
     *  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