lsst::afw::table::BaseColumnView Class Reference

Column-wise view into a sequence of records that have been allocated contiguously. More...

#include <BaseColumnView.h>

Inheritance diagram for lsst::afw::table::BaseColumnView:

Classes
struct	Impl

Public Member Functions
std::shared_ptr< BaseTable >	getTable () const
	Return the table that owns the records.
Schema	getSchema () const
	Return the schema that defines the fields.
template<typename T >
ndarray::ArrayRef< T, 1 > const	operator[] (Key< T > const &key) const
	Return a 1-d array corresponding to a scalar field (or subfield).
template<typename T >
ndarray::ArrayRef< T, 2, 1 > const	operator[] (Key< Array< T > > const &key) const
	Return a 2-d array corresponding to an array field.
ndarray::result_of::vectorize< detail::FlagExtractor, ndarray::Array< Field< Flag >::Elementconst, 1 > >::type	operator[] (Key< Flag > const &key) const
	Return a 1-d array expression corresponding to a flag bit.
ndarray::Array< double, 1 > const	get_radians_array (Key< Angle > const &key) const
	Return an array column as a double array in radians.
BitsColumn	getBits (std::vector< Key< Flag > > const &keys) const
	Return an integer array with the given Flag fields repacked into individual bits.
BitsColumn	getAllBits () const
	Return an integer array with all Flag fields repacked into individual bits.
	BaseColumnView (BaseColumnView const &)
	BaseColumnView (BaseColumnView &&)
BaseColumnView &	operator= (BaseColumnView const &)
BaseColumnView &	operator= (BaseColumnView &&)
	~BaseColumnView ()

Static Public Member Functions
template<typename InputIterator >
static BaseColumnView	make (std::shared_ptr< BaseTable > const &table, InputIterator first, InputIterator last)
	Construct a BaseColumnView from an iterator range.
template<typename InputIterator >
static bool	isRangeContiguous (std::shared_ptr< BaseTable > const &table, InputIterator first, InputIterator last)
	Return true if the given record iterator range is continuous and the records all belong to the given table.

Protected Member Functions
	BaseColumnView (std::shared_ptr< BaseTable > const &table, std::size_t recordCount, void *buf, ndarray::Manager::Ptr const &manager)

Friends
class	BaseTable

Detailed Description

Column-wise view into a sequence of records that have been allocated contiguously.

A BaseColumnView can be created from any iterator range that dereferences to records, as long as those records' field data is contiguous in memory. In practice, that means they must have been created from the same table, and be in the same order they were created (with no deletions). It also requires that those records be allocated in the same block, which can be guaranteed with BaseTable::preallocate().

Geometric (point and shape) fields cannot be accessed through a BaseColumnView, but their scalar components can be.

BaseColumnView and its subclasses are always non-const views into a catalog, and so cannot be obtained from a catalog-of-const (trying this results in an exception, not a compilation error). As a result, all its accessors return arrays of non-const elements, even though they are themselves const member functions. This is no different from a shared_ptr<T>'s get() member function returning a non-const T*, even though get() is a const member function.

Definition at line 83 of file BaseColumnView.h.

Constructor & Destructor Documentation

BaseColumnView() [1/3]

lsst::afw::table::BaseColumnView::BaseColumnView ( BaseColumnView const & )

default

BaseColumnView() [2/3]

lsst::afw::table::BaseColumnView::BaseColumnView ( BaseColumnView && )

default

~BaseColumnView()

lsst::afw::table::BaseColumnView::~BaseColumnView ( )

default

BaseColumnView() [3/3]

lsst::afw::table::BaseColumnView::BaseColumnView ( std::shared_ptr< BaseTable > const & table, std::size_t recordCount, void * buf, ndarray::Manager::Ptr const & manager )

protected

Definition at line 183 of file BaseColumnView.cc.

        : _impl(std::make_shared<Impl>(table, recordCount, buf, manager)) {}

Member Function Documentation

get_radians_array()

ndarray::Array< double, 1 > const lsst::afw::table::BaseColumnView::get_radians_array

(

Key< Angle > const &

key

)

const

Return an array column as a double array in radians.

Definition at line 117 of file BaseColumnView.cc.

                                                                                            {
    using DoubleArray = ndarray::Array<double, 1>;
    using AngleArray = ndarray::Array<lsst::geom::Angle, 1>;
    AngleArray angle_array = (*this)[key];
    return ndarray::detail::ArrayAccess<DoubleArray>::construct(
        reinterpret_cast<double *>(angle_array.getData()),
        ndarray::detail::ArrayAccess<AngleArray>::getCore(angle_array)
    );
}

getAllBits()

BitsColumn lsst::afw::table::BaseColumnView::getAllBits

(

)

const

Return an integer array with all Flag fields repacked into individual bits.

The returned object contains both the int64 array and accessors to obtain a mask given a Key or field name.

Exceptions

pex::exceptions::LengthError

if the schema has more than 64 Flag fields.

Definition at line 157 of file BaseColumnView.cc.

                                            {
    BitsColumn result(_impl->recordCount);
    ExtractFlagItems func = {&result._items};
    getSchema().forEach(func);
    if (result._items.size() > sizeof(BitsColumn::SizeT)) {
        throw LSST_EXCEPT(pex::exceptions::LengthError,
                          (boost::format("Too many Flag keys in schema; %d > %d.") % result._items.size() %
                           sizeof(BitsColumn::SizeT))
                                  .str());
    }
    ndarray::ArrayRef<BitsColumn::SizeT, 1, 1> array = result._array.deep();
    BitsColumn::SizeT const size = result._items.size();  // just for unsigned/signed comparisons
    for (BitsColumn::SizeT i = 0; i < size; ++i) {
        array |= (BitsColumn::SizeT(1) << i) * (*this)[result._items[i].key];
    }
    return result;
}

getBits()

BitsColumn lsst::afw::table::BaseColumnView::getBits

(

std::vector< Key< Flag > > const &

keys

)

const

Return an integer array with the given Flag fields repacked into individual bits.

The returned object contains both the int64 array and accessors to obtain a mask given a Key or field name.

Exceptions

pex::exceptions::LengthError

if keys.size() > 64

Definition at line 127 of file BaseColumnView.cc.

                                                                          {
    BitsColumn result(_impl->recordCount);
    ndarray::ArrayRef<BitsColumn::SizeT, 1, 1> array = result._array.deep();
    if (keys.size() > sizeof(BitsColumn::SizeT)) {
        throw LSST_EXCEPT(pex::exceptions::LengthError,
                          (boost::format("Too many keys passed to getBits(); %d > %d.") % keys.size() %
                           sizeof(BitsColumn::SizeT))
                                  .str());
    }
    BitsColumn::SizeT const size = keys.size();  // just for unsigned/signed comparisons
    for (BitsColumn::SizeT i = 0; i < size; ++i) {
        array |= (BitsColumn::SizeT(1) << i) * (*this)[keys[i]];
        result._items.push_back(getSchema().find(keys[i]));
    }
    return result;
}

getSchema()

Schema lsst::afw::table::BaseColumnView::getSchema ( ) const

inline

Return the schema that defines the fields.

Definition at line 89 of file BaseColumnView.h.

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

getTable()

std::shared_ptr< BaseTable > lsst::afw::table::BaseColumnView::getTable

(

)

const

Return the table that owns the records.

Definition at line 68 of file BaseColumnView.cc.

{ return _impl->table; }

isRangeContiguous()

template<typename InputIterator >

bool lsst::afw::table::BaseColumnView::isRangeContiguous ( std::shared_ptr< BaseTable > const & table, InputIterator first, InputIterator last )

static

Return true if the given record iterator range is continuous and the records all belong to the given table.

This tests exactly the same requiremetns needed to construct a column view, so if this test succeeds, BaseColumnView::make should as well.

Definition at line 221 of file BaseColumnView.h.

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

make()

template<typename InputIterator >

BaseColumnView lsst::afw::table::BaseColumnView::make ( std::shared_ptr< BaseTable > const & table, InputIterator first, InputIterator last )

static

Construct a BaseColumnView from an iterator range.

The iterators must dereference to a reference or const reference to a record. If the record data is not contiguous in memory, throws lsst::pex::exceptions::RuntimeError.

Definition at line 200 of file BaseColumnView.h.

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

operator=() [1/2]

BaseColumnView & lsst::afw::table::BaseColumnView::operator= ( BaseColumnView && )

default

operator=() [2/2]

BaseColumnView & lsst::afw::table::BaseColumnView::operator= ( BaseColumnView const & )

default

operator[]() [1/3]

template<typename T >

ndarray::ArrayRef< T, 2, 1 > const lsst::afw::table::BaseColumnView::operator[]

(

Key< Array< T > > const &

key

)

const

Return a 2-d array corresponding to an array field.

Definition at line 84 of file BaseColumnView.cc.

                                                                                                  {
    if (!key.isValid()) {
        throw LSST_EXCEPT(
            pex::exceptions::LogicError,
            "Key is not valid (if this is a SourceCatalog, make sure slot aliases have been set up).");
    }
    if (key.isVariableLength()) {
        throw LSST_EXCEPT(pex::exceptions::LogicError, "Cannot get columns for variable-length array fields");
    }
    return ndarray::external(
            reinterpret_cast<T *>(reinterpret_cast<char *>(_impl->buf) + key.getOffset()),
            ndarray::makeVector(_impl->recordCount, key.getSize()),
            ndarray::makeVector(_impl->table->getSchema().getRecordSize() / sizeof(T), std::size_t(1)),
            _impl->manager);
}

operator[]() [2/3]

ndarray::result_of::vectorize< detail::FlagExtractor, ndarray::Array< Field< Flag >::Elementconst, 1 > >::type lsst::afw::table::BaseColumnView::operator[]

(

Key< Flag > const &

key

)

const

Return a 1-d array expression corresponding to a flag bit.

In C++, the return value is a lazy ndarray expression template that performs the bitwise & operation on every element when that element is requested. In Python, the result will be copied into a bool NumPy array.

Definition at line 101 of file BaseColumnView.cc.

                                                             {
    if (!key.isValid()) {
        throw LSST_EXCEPT(
            pex::exceptions::LogicError,
            "Key is not valid (if this is a SourceCatalog, make sure slot aliases have been set up).");
    }
    return ndarray::vectorize(detail::FlagExtractor(key),
                              ndarray::Array<Field<Flag>::Element const, 1>(ndarray::external(
                                      reinterpret_cast<Field<Flag>::Element *>(
                                              reinterpret_cast<char *>(_impl->buf) + key.getOffset()),
                                      ndarray::makeVector(_impl->recordCount),
                                      ndarray::makeVector(_impl->table->getSchema().getRecordSize() /
                                                              sizeof(Field<Flag>::Element)),
                                      _impl->manager)));
}

operator[]() [3/3]

template<typename T >

ndarray::ArrayRef< T, 1 > const lsst::afw::table::BaseColumnView::operator[]

(

Key< T > const &

key

)

const

Return a 1-d array corresponding to a scalar field (or subfield).

Definition at line 71 of file BaseColumnView.cc.

                                                                                       {
    if (!key.isValid()) {
        throw LSST_EXCEPT(
            pex::exceptions::LogicError,
            "Key is not valid (if this is a SourceCatalog, make sure slot aliases have been set up).");
    }
    return ndarray::external(reinterpret_cast<T *>(reinterpret_cast<char *>(_impl->buf) + key.getOffset()),
                             ndarray::makeVector(_impl->recordCount),
                             ndarray::makeVector(_impl->table->getSchema().getRecordSize() / sizeof(T)),
                             _impl->manager);
}

Friends And Related Symbol Documentation

BaseTable

friend class BaseTable

friend

Definition at line 165 of file BaseColumnView.h.

---

The documentation for this class was generated from the following files:

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-8.0.0/Linux64/afw/g5a732f18d5+53520f316c/include/lsst/afw/table/BaseColumnView.h
• /j/snowflake/release/lsstsw/stack/lsst-scipipe-8.0.0/Linux64/afw/g5a732f18d5+53520f316c/src/table/BaseColumnView.cc