lsst::afw::table::ColumnViewT< RecordT > Class Template Reference

#include <BaseColumnView.h>

Inheritance diagram for lsst::afw::table::ColumnViewT< RecordT >:

Public Types
using	Record = RecordT
using	Table = typename RecordT::Table

Public Member Functions
std::shared_ptr< Table >	getTable () const
	Return the table that owns the records.
	ColumnViewT (ColumnViewT const &)=default
	ColumnViewT (ColumnViewT &&)=default
ColumnViewT &	operator= (ColumnViewT const &)=default
ColumnViewT &	operator= (ColumnViewT &&)=default
	~ColumnViewT ()=default
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.

Static Public Member Functions
template<typename InputIterator>
static ColumnViewT	make (std::shared_ptr< Table > const &table, InputIterator first, InputIterator last)
	Construct a BaseColumnView from an iterator range.
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
	ColumnViewT (BaseColumnView const &base)

Detailed Description

template<typename RecordT>
class lsst::afw::table::ColumnViewT< RecordT >

Definition at line 173 of file BaseColumnView.h.

Member Typedef Documentation

Record

template<typename RecordT>

using lsst::afw::table::ColumnViewT< RecordT >::Record = RecordT

Definition at line 175 of file BaseColumnView.h.

Table

template<typename RecordT>

using lsst::afw::table::ColumnViewT< RecordT >::Table = typename RecordT::Table

Definition at line 176 of file BaseColumnView.h.

Constructor & Destructor Documentation

ColumnViewT() [1/3]

template<typename RecordT>

lsst::afw::table::ColumnViewT< RecordT >::ColumnViewT ( ColumnViewT< RecordT > const & )

default

ColumnViewT() [2/3]

template<typename RecordT>

lsst::afw::table::ColumnViewT< RecordT >::ColumnViewT ( ColumnViewT< RecordT > && )

default

~ColumnViewT()

template<typename RecordT>

lsst::afw::table::ColumnViewT< RecordT >::~ColumnViewT ( )

default

ColumnViewT() [3/3]

template<typename RecordT>

lsst::afw::table::ColumnViewT< RecordT >::ColumnViewT ( BaseColumnView const & base )

inlineexplicitprotected

Definition at line 196 of file BaseColumnView.h.

: BaseColumnView(base) {}

Member Function Documentation

get_radians_array()

ndarray::Array< double, 1 > const lsst::afw::table::BaseColumnView::get_radians_array ( Key< Angle > const & key ) const

inherited

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

inherited

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

inherited

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

inlineinherited

Return the schema that defines the fields.

Definition at line 89 of file BaseColumnView.h.

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

getTable()

template<typename RecordT>

std::shared_ptr< Table > lsst::afw::table::ColumnViewT< RecordT >::getTable ( ) const

inline

Return the table that owns the records.

Definition at line 179 of file BaseColumnView.h.

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

isRangeContiguous()

template<typename InputIterator>

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

staticinherited

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() [1/2]

template<typename InputIterator>

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

staticinherited

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

make() [2/2]

template<typename RecordT>

template<typename InputIterator>

static ColumnViewT lsst::afw::table::ColumnViewT< RecordT >::make ( std::shared_ptr< Table > const & table, InputIterator first, InputIterator last )

inlinestatic

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 185 of file BaseColumnView.h.

                                                                                                        {
        return ColumnViewT(BaseColumnView::make(table, first, last));
    }

operator=() [1/2]

template<typename RecordT>

ColumnViewT & lsst::afw::table::ColumnViewT< RecordT >::operator= ( ColumnViewT< RecordT > && )

default

operator=() [2/2]

template<typename RecordT>

ColumnViewT & lsst::afw::table::ColumnViewT< RecordT >::operator= ( ColumnViewT< RecordT > 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

inherited

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

inherited

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

inherited

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

---

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

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-12.1.0/Linux/afw/g7ae74a0b1c+a25e60b391/include/lsst/afw/table/BaseColumnView.h