LSST Applications g063fba187b+fee0456c91,g0f08755f38+ea96e5a5a3,g1653933729+a8ce1bb630,g168dd56ebc+a8ce1bb630,g1a2382251a+90257ff92a,g20f6ffc8e0+ea96e5a5a3,g217e2c1bcf+937a289c59,g28da252d5a+daa7da44eb,g2bbee38e9b+253935c60e,g2bc492864f+253935c60e,g3156d2b45e+6e55a43351,g32e5bea42b+31359a2a7a,g347aa1857d+253935c60e,g35bb328faa+a8ce1bb630,g3a166c0a6a+253935c60e,g3b1af351f3+a8ce1bb630,g3e281a1b8c+c5dd892a6c,g414038480c+416496e02f,g41af890bb2+afe91b1188,g599934f4f4+0db33f7991,g7af13505b9+e36de7bce6,g80478fca09+da231ba887,g82479be7b0+a4516e59e3,g858d7b2824+ea96e5a5a3,g89c8672015+f4add4ffd5,g9125e01d80+a8ce1bb630,ga5288a1d22+bc6ab8dfbd,gb58c049af0+d64f4d3760,gc28159a63d+253935c60e,gcab2d0539d+3f2b72788c,gcf0d15dbbd+4ea9c45075,gda6a2b7d83+4ea9c45075,gdaeeff99f8+1711a396fd,ge79ae78c31+253935c60e,gef2f8181fd+3031e3cf99,gf0baf85859+c1f95f4921,gfa517265be+ea96e5a5a3,gfa999e8aa5+17cd334064,w.2024.50
LSST Data Management Base Package
Loading...
Searching...
No Matches
BaseColumnView.h
Go to the documentation of this file.
1// -*- lsst-c++ -*-
2#ifndef AFW_TABLE_BaseColumnView_h_INCLUDED
3#define AFW_TABLE_BaseColumnView_h_INCLUDED
4
5#include <cstdint>
6
8
9namespace lsst {
10namespace afw {
11namespace table {
12
13namespace detail {
14
19
21
22 explicit FlagExtractor(Key<Flag> const& key) : _mask(argument_type(1) << key.getBit()) {}
23
24private:
25 argument_type _mask;
26};
27
28} // namespace detail
29
30class BaseTable;
31
32class BaseColumnView;
33
43public:
45
46 ndarray::Array<SizeT, 1, 1> getArray() const { return _array; }
47
48 SizeT getBit(Key<Flag> const& key) const;
49 SizeT getBit(std::string const& name) const;
50
51 SizeT getMask(Key<Flag> const& key) const { return SizeT(1) << getBit(key); }
52 SizeT getMask(std::string const& name) const { return SizeT(1) << getBit(name); }
53
54 std::vector<SchemaItem<Flag> > const& getSchemaItems() const { return _items; }
55
56private:
57 friend class BaseColumnView;
58
59 explicit BitsColumn(std::size_t size);
60
61 ndarray::Array<SizeT, 1, 1> _array;
63};
64
84public:
87
89 Schema getSchema() const { return getTable()->getSchema(); }
90
92 template <typename T>
93 ndarray::ArrayRef<T, 1> const operator[](Key<T> const& key) const;
94
96 template <typename T>
97 ndarray::ArrayRef<T, 2, 1> const operator[](Key<Array<T> > const& key) const;
98
106 ndarray::result_of::vectorize<detail::FlagExtractor, ndarray::Array<Field<Flag>::Element const, 1> >::type
107 operator[](Key<Flag> const& key) const;
108
110 ndarray::Array<double, 1> const get_radians_array(Key<Angle> const & key) const;
111
120 BitsColumn getBits(std::vector<Key<Flag> > const& keys) const;
121
130 BitsColumn getAllBits() const;
131
138 template <typename InputIterator>
140 InputIterator last);
141
149 template <typename InputIterator>
151 InputIterator last);
152
157
159
160protected:
161 BaseColumnView(std::shared_ptr<BaseTable> const& table, std::size_t recordCount, void* buf,
162 ndarray::Manager::Ptr const& manager);
163
164private:
165 friend class BaseTable;
166
167 struct Impl;
168
170};
171
172template <typename RecordT>
174public:
176 using Table = typename RecordT::Table;
177
180 return std::static_pointer_cast<Table>(BaseColumnView::getTable());
181 }
182
184 template <typename InputIterator>
186 return ColumnViewT(BaseColumnView::make(table, first, last));
187 }
188
189 ColumnViewT(ColumnViewT const&) = default;
193 ~ColumnViewT() = default;
194
195protected:
196 explicit ColumnViewT(BaseColumnView const& base) : BaseColumnView(base) {}
197};
198
199template <typename InputIterator>
201 InputIterator last) {
202 if (first == last) {
203 return BaseColumnView(table, 0, nullptr, ndarray::Manager::Ptr());
204 }
205 Schema schema = table->getSchema();
206 std::size_t recordSize = schema.getRecordSize();
207 std::size_t recordCount = 1;
208 void* buf = first->_data;
209 ndarray::Manager::Ptr manager = first->_manager;
210 char* expected = reinterpret_cast<char*>(buf) + recordSize;
211 for (++first; first != last; ++first, ++recordCount, expected += recordSize) {
212 if (first->_data != expected || first->_manager != manager) {
214 "Record data is not contiguous in memory.");
215 }
216 }
217 return BaseColumnView(table, recordCount, buf, manager);
218}
219
220template <typename InputIterator>
222 InputIterator last) {
223 if (first == last) return true;
224 Schema schema = table->getSchema();
225 std::size_t recordSize = schema.getRecordSize();
226 std::size_t recordCount = 1;
227 void* buf = first->_data;
228 ndarray::Manager::Ptr manager = first->_manager;
229 char* expected = reinterpret_cast<char*>(buf) + recordSize;
230 for (++first; first != last; ++first, ++recordCount, expected += recordSize) {
231 if (first->_data != expected || first->_manager != manager) {
232 return false;
233 }
234 }
235 return true;
236}
237} // namespace table
238} // namespace afw
239} // namespace lsst
240
241#endif // !AFW_TABLE_BaseColumnView_h_INCLUDED
double element[2]
Definition BaseTable.cc:90
#define LSST_EXCEPT(type,...)
Create an exception with a given type.
Definition Exception.h:48
table::Schema schema
Definition python.h:134
Tag types used to declare specialized field types.
Definition misc.h:31
Column-wise view into a sequence of records that have been allocated contiguously.
BaseColumnView & operator=(BaseColumnView const &)
BitsColumn getBits(std::vector< Key< Flag > > const &keys) const
Return an integer array with the given Flag fields repacked into individual bits.
Schema getSchema() const
Return the schema that defines the fields.
BaseColumnView & operator=(BaseColumnView &&)
BaseColumnView(BaseColumnView const &)
BaseColumnView(BaseColumnView &&)
static BaseColumnView make(std::shared_ptr< BaseTable > const &table, InputIterator first, InputIterator last)
Construct a BaseColumnView from an iterator range.
BitsColumn getAllBits() const
Return an integer array with all Flag fields repacked into individual bits.
ndarray::Array< double, 1 > const get_radians_array(Key< Angle > const &key) const
Return an array column as a double array in radians.
std::shared_ptr< BaseTable > getTable() const
Return the table that owns the records.
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 ...
ndarray::ArrayRef< T, 1 > const operator[](Key< T > const &key) const
Return a 1-d array corresponding to a scalar field (or subfield).
Base class for all tables.
Definition BaseTable.h:61
A packed representation of a collection of Flag field columns.
std::vector< SchemaItem< Flag > > const & getSchemaItems() const
SizeT getMask(Key< Flag > const &key) const
SizeT getBit(Key< Flag > const &key) const
ndarray::Array< SizeT, 1, 1 > getArray() const
SizeT getMask(std::string const &name) const
typename RecordT::Table Table
std::shared_ptr< Table > getTable() const
Return the table that owns the records.
ColumnViewT(ColumnViewT const &)=default
ColumnViewT(ColumnViewT &&)=default
ColumnViewT(BaseColumnView const &base)
ColumnViewT & operator=(ColumnViewT const &)=default
ColumnViewT & operator=(ColumnViewT &&)=default
static ColumnViewT make(std::shared_ptr< Table > const &table, InputIterator first, InputIterator last)
Construct a BaseColumnView from an iterator range.
A class used as a handle to a particular field in a table.
Definition Key.h:53
Defines the fields and offsets for a table.
Definition Schema.h:51
Reports errors that are due to events beyond the control of the program.
Definition Runtime.h:104
decltype(sizeof(void *)) size_t
Definition doctest.h:524
typename FieldBase< T >::Element Element
Type used to store field data in the table (a field may have multiple elements).
Definition Field.h:26
Functor to compute a flag bit, used to create an ndarray expression template for flag columns.
result_type operator()(argument_type element) const