BaseRecord.h

Go to the documentation of this file.

// -*- lsst-c++ -*-
#ifndef AFW_TABLE_BaseRecord_h_INCLUDED
#define AFW_TABLE_BaseRecord_h_INCLUDED

#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
#ifndef SWIG // swig complains about these not being %shared_ptr, and it doesn't need to know about them
    : public daf::base::Citizen,
      private boost::noncopyable
#endif
{
public:

    typedef BaseTable Table;

    typedef BaseColumnView ColumnView;

    typedef CatalogT<BaseRecord> Catalog;

    typedef CatalogT<BaseRecord const> ConstCatalog;

    Schema getSchema() const { return _table->getSchema(); }

    CONST_PTR(BaseTable) 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 setup)."
            );
        }
        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 setup)."
            );
        }
        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);
    }

#ifndef SWIG

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

#endif // !SWIG

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

protected:

    virtual void _assign(BaseRecord const & other) {}

    BaseRecord(PTR(BaseTable) const & table) : daf::base::Citizen(typeid(this)), _table(table) {
        table->_initialize(*this);
    }

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
    PTR(BaseTable) _table;          // the associated table
    ndarray::Manager::Ptr _manager; // shared manager for lifetime of _data (like shared_ptr with no pointer)
};

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

#endif // !AFW_TABLE_BaseRecord_h_INCLUDED