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 {
    using argument_type = Field<Flag>::Element;
    using result_type = bool;
 
    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:
    using SizeT = std::size_t;
 
    ndarray::Array<SizeT, 1, 1> getArray() const { return _array; }
 
    SizeT getBit(Key<Flag> const& key) const;
    SizeT getBit(std::string const& name) const;
 
    SizeT getMask(Key<Flag> const& key) const { return SizeT(1) << getBit(key); }
    SizeT getMask(std::string const& name) const { return SizeT(1) << getBit(name); }
 
    std::vector<SchemaItem<Flag> > const& getSchemaItems() const { return _items; }
 
private:
    friend class BaseColumnView;
 
    explicit BitsColumn(std::size_t size);
 
    ndarray::Array<SizeT, 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, std::size_t 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:
    using Record = RecordT;
    using Table = typename RecordT::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, nullptr, 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