BaseColumnView.h

Go to the documentation of this file.

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

#include "lsst/afw/table/BaseTable.h"

namespace lsst { namespace afw { namespace table {

namespace detail {

struct FlagExtractor {
    typedef Field<Flag>::Element argument_type;
    typedef bool result_type;

    result_type operator()(argument_type element) const { return element & _mask; }

    explicit FlagExtractor(Key<Flag> const & key) : _mask(argument_type(1) << key.getBit()) {}

private:
    argument_type _mask;
};

} // namespace detail

class BaseTable;

class BaseColumnView;

class BitsColumn {
public:

    typedef boost::int64_t IntT;

    ndarray::Array<IntT,1,1> getArray() const { return _array; }

    IntT getBit(Key<Flag> const & key) const;
    IntT getBit(std::string const & name) const;

    IntT getMask(Key<Flag> const & key) const { return IntT(1) << getBit(key); }
    IntT getMask(std::string const & name) const { return IntT(1) << getBit(name); }

#ifndef SWIG
    std::vector< SchemaItem<Flag> > const & getSchemaItems() const { return _items; }
#endif

private:

    friend class BaseColumnView;

    explicit BitsColumn(int size);

    ndarray::Array<IntT,1,1> _array;
    std::vector< SchemaItem<Flag> > _items;
};

class BaseColumnView {
public:

    PTR(BaseTable) getTable() const;

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

    template <typename T>
    ndarray::ArrayRef<T,1> const operator[](Key<T> const & key) const;

    template <typename T>
    ndarray::ArrayRef<T,2,1> const operator[](Key< Array<T> > const & key) const;

    ndarray::result_of::vectorize< detail::FlagExtractor,
                                   ndarray::Array< Field<Flag>::Element const,1> >::type
    operator[](Key<Flag> const & key) const;

    BitsColumn getBits(std::vector< Key<Flag> > const & keys) const;

    BitsColumn getAllBits() const;

    template <typename InputIterator>
    static BaseColumnView make(PTR(BaseTable) const & table, InputIterator first, InputIterator last);

    template <typename InputIterator>
    static bool isRangeContiguous(PTR(BaseTable) const & table, InputIterator first, InputIterator last);

    ~BaseColumnView();

protected:

    BaseColumnView(
        PTR(BaseTable) const & table, int recordCount, void * buf, ndarray::Manager::Ptr const & manager
    );

private:

    friend class BaseTable;

    struct Impl;

    boost::shared_ptr<Impl> _impl;
};

template <typename RecordT>
class ColumnViewT : public BaseColumnView {
public:

    typedef RecordT Record;
    typedef typename RecordT::Table Table;

    PTR(Table) getTable() const { return boost::static_pointer_cast<Table>(BaseColumnView::getTable()); }

    template <typename InputIterator>
    static ColumnViewT make(PTR(Table) const & table, InputIterator first, InputIterator last) {
        return ColumnViewT(BaseColumnView::make(table, first, last));
    }

protected:

    explicit ColumnViewT(BaseColumnView const & base) : BaseColumnView(base) {}

};

template <typename InputIterator>
BaseColumnView BaseColumnView::make(PTR(BaseTable) const & table, InputIterator first, InputIterator last) {
    if (first == last) {
        return BaseColumnView(table, 0, 0, ndarray::Manager::Ptr());
    }
    Schema schema = table->getSchema();
    std::size_t recordSize = schema.getRecordSize();
    std::size_t recordCount = 1;
    void * buf = first->_data;
    ndarray::Manager::Ptr manager = first->_manager;
    char * expected = reinterpret_cast<char*>(buf) + recordSize;
    for (++first; first != last; ++first, ++recordCount, expected += recordSize) {
        if (first->_data != expected || first->_manager != manager) {
            throw LSST_EXCEPT(
                lsst::pex::exceptions::RuntimeError,
                "Record data is not contiguous in memory."
            );
        }
    }
    return BaseColumnView(table, recordCount, buf, manager);
}

template <typename InputIterator>
bool BaseColumnView::isRangeContiguous(
    PTR(BaseTable) const & table, InputIterator first, InputIterator last
) {
    if (first == last) return true;
    Schema schema = table->getSchema();
    std::size_t recordSize = schema.getRecordSize();
    std::size_t recordCount = 1;
    void * buf = first->_data;
    ndarray::Manager::Ptr manager = first->_manager;
    char * expected = reinterpret_cast<char*>(buf) + recordSize;
    for (++first; first != last; ++first, ++recordCount, expected += recordSize) {
        if (first->_data != expected || first->_manager != manager) {
            return false;
        }
    }
    return true;
}

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

#endif // !AFW_TABLE_BaseColumnView_h_INCLUDED