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
#ifndef SWIG // swig complains about these not being %shared_ptrs, but it doesn't need to know about them
: public std::enable_shared_from_this<BaseTable>,
  public daf::base::Citizen
#endif
{
public:

    typedef BaseRecord Record;

    typedef BaseColumnView ColumnView;

    typedef CatalogT<Record> Catalog;

    typedef CatalogT<Record const> ConstCatalog;

    static int nRecordsPerBlock;

    PTR(daf::base::PropertyList) getMetadata() const { return _metadata; }

    void setMetadata(PTR(daf::base::PropertyList) const & metadata) { _metadata = metadata; }

    PTR(daf::base::PropertyList) popMetadata() {
        PTR(daf::base::PropertyList) tmp;
        _metadata.swap(tmp);
        return tmp;
    }

    PTR(BaseTable) clone() const { return _clone(); }

    PTR(BaseRecord) makeRecord() { return _makeRecord(); }

    PTR(BaseRecord) copyRecord(BaseRecord const & input);

    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 PTR(BaseTable) make(Schema const & schema);

    virtual ~BaseTable();

protected:

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

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

    virtual void handleAliasChange(std::string const & alias) {}

    virtual PTR(BaseTable) _clone() const = 0;

    virtual PTR(BaseRecord) _makeRecord() = 0;

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

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

    // Tables are not assignable to prevent type slicing; this is intentionally not implemented,
    // so we get linker errors if we do try to use the assignment operator.
    void operator=(BaseTable const & other);

    // Return a writer object that knows how to save in FITS format.  See also FitsWriter.
    virtual 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
    PTR(daf::base::PropertyList) _metadata; // flexible metadata; may be null
};

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

#endif // !AFW_TABLE_BaseTable_h_INCLUDED