BaseRecord.h

Go to the documentation of this file.

// -*- lsst-c++ -*-
#ifndef AFW_TABLE_BaseRecord_h_INCLUDED
#define AFW_TABLE_BaseRecord_h_INCLUDED
 
#include <iosfwd>
 
#include "lsst/base.h"
#include "lsst/afw/table/fwd.h"
#include "lsst/afw/table/Schema.h"
#include "lsst/afw/table/BaseTable.h"
#include "lsst/afw/table/FunctorKey.h"
 
namespace lsst {
namespace afw {
namespace table {
 
class BaseRecord {
protected:
 
    // Protected class whose instances must be passed to the public
    // constructor, providing more fine-grained access control than a
    // protected constructor would.  In particular, this allows make_shared to
    // be used.
    class ConstructionToken {
    private:
        friend class BaseTable;
 
        // A private ctor for this class (and friendship) is necessary to
        // prevent e.g. BaseRecord({}, ...) calls from code without access
        // to ConstructionToken.
        explicit ConstructionToken(int) noexcept {}
    };
 
public:
 
    BaseRecord(ConstructionToken const &, detail::RecordData && data);
    // No copying
    BaseRecord(const BaseRecord&) = delete;
    BaseRecord& operator=(const BaseRecord&) = delete;
 
    // No moving
    BaseRecord(BaseRecord&&) = delete;
    BaseRecord& operator=(BaseRecord&&) = delete;
 
    using Table = BaseTable;
 
    using ColumnView = BaseColumnView;
 
    using Catalog = CatalogT<BaseRecord>;
 
    using ConstCatalog = CatalogT<const BaseRecord>;
 
    Schema getSchema() const { return _table->getSchema(); }
 
    std::shared_ptr<BaseTable const> getTable() const { return _table; }
 
    template <typename T>
    typename Field<T>::Element* getElement(Key<T> const& key) {
        if (!key.isValid()) {
            throw LSST_EXCEPT(
                    pex::exceptions::LogicError,
                    "Key is not valid (if this is a SourceRecord, make sure slot aliases have been set up).");
        }
        return reinterpret_cast<typename Field<T>::Element*>(reinterpret_cast<char*>(_data) +
                                                             key.getOffset());
    }
 
    template <typename T>
    typename Field<T>::Element const* getElement(Key<T> const& key) const {
        if (!key.isValid()) {
            throw LSST_EXCEPT(
                    pex::exceptions::LogicError,
                    "Key is not valid (if this is a SourceRecord, make sure slot aliases have been set up).");
        }
        return reinterpret_cast<typename Field<T>::Element const*>(reinterpret_cast<char const*>(_data) +
                                                                   key.getOffset());
    }
 
    template <typename T>
    typename Field<T>::Reference operator[](Key<T> const& key) {
        return key.getReference(getElement(key), _manager);
    }
 
    template <typename T>
    typename Field<T>::ConstReference operator[](Key<T> const& key) const {
        return key.getConstReference(getElement(key), _manager);
    }
 
    template <typename T>
    typename Field<T>::Value get(Key<T> const& key) const {
        return key.getValue(getElement(key), _manager);
    }
 
    template <typename T, typename U>
    void set(Key<T> const& key, U const& value) {
        key.setValue(getElement(key), _manager, value);
    }
 
    template <typename T>
    T get(OutputFunctorKey<T> const& key) const {
        return key.get(*this);
    }
 
    template <typename T, typename U>
    void set(InputFunctorKey<T> const& key, U const& value) {
        return key.set(*this, value);
    }
 
    template <typename Ref>
    Ref operator[](ReferenceFunctorKey<Ref> const& key) {
        return key.getReference(*this);
    }
 
    template <typename ConstRef>
    ConstRef operator[](ConstReferenceFunctorKey<ConstRef> const& key) const {
        return key.getConstReference(*this);
    }
 
    void assign(BaseRecord const& other);
 
    void assign(BaseRecord const& other, SchemaMapper const& mapper);
 
    ndarray::Manager::Ptr getManager() const { return _manager; }
 
    virtual ~BaseRecord() { _table->_destroy(*this); }
 
    friend std::ostream& operator<<(std::ostream& os, BaseRecord const& record);
 
protected:
    virtual void _assign(BaseRecord const& other) {}
 
    virtual void _stream(std::ostream& os) const;
 
 
private:
    friend class BaseTable;
    friend class BaseColumnView;
 
    // All these are definitely private, not protected - we don't want derived classes mucking with them.
    void* _data;                        // pointer to field data
    std::shared_ptr<BaseTable> _table;  // the associated table
    ndarray::Manager::Ptr _manager;  // shared manager for lifetime of _data (like shared_ptr with no pointer)
};
 
template <typename RecordT, typename ...Args>
std::shared_ptr<RecordT> BaseTable::constructRecord(Args && ...args) {
    return std::make_shared<RecordT>(BaseRecord::ConstructionToken(0), _makeNewRecordData(),
                                     std::forward<Args>(args)...);
}
 
 
}  // namespace table
}  // namespace afw
}  // namespace lsst
 
#endif  // !AFW_TABLE_BaseRecord_h_INCLUDED