LSST Applications  21.0.0-172-gfb10e10a+18fedfabac,22.0.0+297cba6710,22.0.0+80564b0ff1,22.0.0+8d77f4f51a,22.0.0+a28f4c53b1,22.0.0+dcf3732eb2,22.0.1-1-g7d6de66+2a20fdde0d,22.0.1-1-g8e32f31+297cba6710,22.0.1-1-geca5380+7fa3b7d9b6,22.0.1-12-g44dc1dc+2a20fdde0d,22.0.1-15-g6a90155+515f58c32b,22.0.1-16-g9282f48+790f5f2caa,22.0.1-2-g92698f7+dcf3732eb2,22.0.1-2-ga9b0f51+7fa3b7d9b6,22.0.1-2-gd1925c9+bf4f0e694f,22.0.1-24-g1ad7a390+a9625a72a8,22.0.1-25-g5bf6245+3ad8ecd50b,22.0.1-25-gb120d7b+8b5510f75f,22.0.1-27-g97737f7+2a20fdde0d,22.0.1-32-gf62ce7b1+aa4237961e,22.0.1-4-g0b3f228+2a20fdde0d,22.0.1-4-g243d05b+871c1b8305,22.0.1-4-g3a563be+32dcf1063f,22.0.1-4-g44f2e3d+9e4ab0f4fa,22.0.1-42-gca6935d93+ba5e5ca3eb,22.0.1-5-g15c806e+85460ae5f3,22.0.1-5-g58711c4+611d128589,22.0.1-5-g75bb458+99c117b92f,22.0.1-6-g1c63a23+7fa3b7d9b6,22.0.1-6-g50866e6+84ff5a128b,22.0.1-6-g8d3140d+720564cf76,22.0.1-6-gd805d02+cc5644f571,22.0.1-8-ge5750ce+85460ae5f3,master-g6e05de7fdc+babf819c66,master-g99da0e417a+8d77f4f51a,w.2021.48
LSST Data Management Base Package
Public Types | Public Member Functions | Static Public Member Functions | Protected Member Functions | List of all members
lsst::afw::table::ColumnViewT< RecordT > Class Template Reference

#include <BaseColumnView.h>

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

Public Types

using Record = RecordT
 
using Table = typename RecordT::Table
 

Public Member Functions

std::shared_ptr< TablegetTable () const
 Return the table that owns the records. More...
 
 ColumnViewT (ColumnViewT const &)=default
 
 ColumnViewT (ColumnViewT &&)=default
 
ColumnViewToperator= (ColumnViewT const &)=default
 
ColumnViewToperator= (ColumnViewT &&)=default
 
 ~ColumnViewT ()=default
 
Schema getSchema () const
 Return the schema that defines the fields. More...
 
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). More...
 
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. More...
 
ndarray::result_of::vectorize< detail::FlagExtractor, ndarray::Array< Field< Flag >::Element const, 1 > >::type operator[] (Key< Flag > const &key) const
 Return a 1-d array expression corresponding to a flag bit. More...
 
BitsColumn getBits (std::vector< Key< Flag > > const &keys) const
 Return an integer array with the given Flag fields repacked into individual bits. More...
 
BitsColumn getAllBits () const
 Return an integer array with all Flag fields repacked into individual bits. More...
 

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. More...
 
template<typename InputIterator >
static BaseColumnView make (std::shared_ptr< BaseTable > const &table, InputIterator first, InputIterator last)
 Construct a BaseColumnView from an iterator range. More...
 
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. More...
 

Protected Member Functions

 ColumnViewT (BaseColumnView const &base)
 

Detailed Description

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

Definition at line 170 of file BaseColumnView.h.

Member Typedef Documentation

◆ Record

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

Definition at line 172 of file BaseColumnView.h.

◆ Table

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

Definition at line 173 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 193 of file BaseColumnView.h.

193 : BaseColumnView(base) {}
BaseColumnView(BaseColumnView const &)

Member Function Documentation

◆ 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::LengthErrorif the schema has more than 64 Flag fields.

Definition at line 147 of file BaseColumnView.cc.

147  {
148  BitsColumn result(_impl->recordCount);
149  ExtractFlagItems func = {&result._items};
150  getSchema().forEach(func);
151  if (result._items.size() > sizeof(BitsColumn::SizeT)) {
152  throw LSST_EXCEPT(pex::exceptions::LengthError,
153  (boost::format("Too many Flag keys in schema; %d > %d.") % result._items.size() %
154  sizeof(BitsColumn::SizeT))
155  .str());
156  }
157  ndarray::ArrayRef<BitsColumn::SizeT, 1, 1> array = result._array.deep();
158  BitsColumn::SizeT const size = result._items.size(); // just for unsigned/signed comparisons
159  for (BitsColumn::SizeT i = 0; i < size; ++i) {
160  array |= (BitsColumn::SizeT(1) << i) * (*this)[result._items[i].key];
161  }
162  return result;
163 }
py::object result
Definition: _schema.cc:429
#define LSST_EXCEPT(type,...)
Create an exception with a given type.
Definition: Exception.h:48
Schema getSchema() const
Return the schema that defines the fields.
void forEach(F &func) const
Apply a functor to each SchemaItem in the Schema.
Definition: Schema.h:214
def format(config, name=None, writeSourceLine=True, prefix="", verbose=False)
Definition: history.py:174

◆ 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::LengthErrorif keys.size() > 64

Definition at line 117 of file BaseColumnView.cc.

117  {
118  BitsColumn result(_impl->recordCount);
119  ndarray::ArrayRef<BitsColumn::SizeT, 1, 1> array = result._array.deep();
120  if (keys.size() > sizeof(BitsColumn::SizeT)) {
121  throw LSST_EXCEPT(pex::exceptions::LengthError,
122  (boost::format("Too many keys passed to getBits(); %d > %d.") % keys.size() %
123  sizeof(BitsColumn::SizeT))
124  .str());
125  }
126  BitsColumn::SizeT const size = keys.size(); // just for unsigned/signed comparisons
127  for (BitsColumn::SizeT i = 0; i < size; ++i) {
128  array |= (BitsColumn::SizeT(1) << i) * (*this)[keys[i]];
129  result._items.push_back(getSchema().find(keys[i]));
130  }
131  return result;
132 }
SchemaItem< T > find(std::string const &name) const
Find a SchemaItem in the Schema by name.
Definition: Schema.cc:467

◆ getSchema()

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

Return the schema that defines the fields.

Definition at line 89 of file BaseColumnView.h.

89 { return getTable()->getSchema(); }
std::shared_ptr< BaseTable > getTable() const
Return the table that owns the records.

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

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

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

219  {
220  if (first == last) return true;
221  Schema schema = table->getSchema();
222  std::size_t recordSize = schema.getRecordSize();
223  std::size_t recordCount = 1;
224  void* buf = first->_data;
225  ndarray::Manager::Ptr manager = first->_manager;
226  char* expected = reinterpret_cast<char*>(buf) + recordSize;
227  for (++first; first != last; ++first, ++recordCount, expected += recordSize) {
228  if (first->_data != expected || first->_manager != manager) {
229  return false;
230  }
231  }
232  return true;
233 }
table::Schema schema
Definition: python.h:134

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

198  {
199  if (first == last) {
200  return BaseColumnView(table, 0, nullptr, ndarray::Manager::Ptr());
201  }
202  Schema schema = table->getSchema();
203  std::size_t recordSize = schema.getRecordSize();
204  std::size_t recordCount = 1;
205  void* buf = first->_data;
206  ndarray::Manager::Ptr manager = first->_manager;
207  char* expected = reinterpret_cast<char*>(buf) + recordSize;
208  for (++first; first != last; ++first, ++recordCount, expected += recordSize) {
209  if (first->_data != expected || first->_manager != manager) {
211  "Record data is not contiguous in memory.");
212  }
213  }
214  return BaseColumnView(table, recordCount, buf, manager);
215 }
Reports errors that are due to events beyond the control of the program.
Definition: Runtime.h:104

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

182  {
183  return ColumnViewT(BaseColumnView::make(table, first, last));
184  }
static BaseColumnView make(std::shared_ptr< BaseTable > const &table, InputIterator first, InputIterator last)
Construct a BaseColumnView from an iterator range.
ColumnViewT(ColumnViewT const &)=default

◆ 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.

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

◆ operator[]() [2/3]

ndarray::result_of::vectorize< detail::FlagExtractor, ndarray::Array< Field< Flag >::Element const, 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.

101  {
102  if (!key.isValid()) {
103  throw LSST_EXCEPT(
104  pex::exceptions::LogicError,
105  "Key is not valid (if this is a SourceCatalog, make sure slot aliases have been set up).");
106  }
107  return ndarray::vectorize(detail::FlagExtractor(key),
108  ndarray::Array<Field<Flag>::Element const, 1>(ndarray::external(
109  reinterpret_cast<Field<Flag>::Element *>(
110  reinterpret_cast<char *>(_impl->buf) + key.getOffset()),
111  ndarray::makeVector(_impl->recordCount),
112  ndarray::makeVector(_impl->table->getSchema().getRecordSize() /
113  sizeof(Field<Flag>::Element)),
114  _impl->manager)));
115 }
typename FieldBase< Flag >::Element Element
Type used to store field data in the table (a field may have multiple elements).
Definition: Field.h:26

◆ 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.

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

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