BaseColumnView.h

Go to the documentation of this file.

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

#include <cstdint>

#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 final {
public:
    typedef std::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); }

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

private:
    friend class BaseColumnView;

    explicit BitsColumn(int size);

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

class BaseColumnView {
public:
    std::shared_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(std::shared_ptr<BaseTable> const& table, InputIterator first,
                               InputIterator last);

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

    BaseColumnView(BaseColumnView const&);
    BaseColumnView(BaseColumnView&&);
    BaseColumnView& operator=(BaseColumnView const&);
    BaseColumnView& operator=(BaseColumnView&&);

    ~BaseColumnView();

protected:
    BaseColumnView(std::shared_ptr<BaseTable> const& table, int recordCount, void* buf,
                   ndarray::Manager::Ptr const& manager);

private:
    friend class BaseTable;

    struct Impl;

    std::shared_ptr<Impl> _impl;
};

template <typename RecordT>
class ColumnViewT : public BaseColumnView {
public:
    typedef RecordT Record;
    typedef typename RecordT::Table Table;

    std::shared_ptr<Table> getTable() const {
        return std::static_pointer_cast<Table>(BaseColumnView::getTable());
    }

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

    ColumnViewT(ColumnViewT const&) = default;
    ColumnViewT(ColumnViewT&&) = default;
    ColumnViewT& operator=(ColumnViewT const&) = default;
    ColumnViewT& operator=(ColumnViewT&&) = default;
    ~ColumnViewT() = default;

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

template <typename InputIterator>
BaseColumnView BaseColumnView::make(std::shared_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(std::shared_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 table
}  // namespace afw
}  // namespace lsst

#endif  // !AFW_TABLE_BaseColumnView_h_INCLUDED