LSSTApplications  17.0+11,17.0+34,17.0+56,17.0+57,17.0+59,17.0+7,17.0-1-g377950a+33,17.0.1-1-g114240f+2,17.0.1-1-g4d4fbc4+28,17.0.1-1-g55520dc+49,17.0.1-1-g5f4ed7e+52,17.0.1-1-g6dd7d69+17,17.0.1-1-g8de6c91+11,17.0.1-1-gb9095d2+7,17.0.1-1-ge9fec5e+5,17.0.1-1-gf4e0155+55,17.0.1-1-gfc65f5f+50,17.0.1-1-gfc6fb1f+20,17.0.1-10-g87f9f3f+1,17.0.1-11-ge9de802+16,17.0.1-16-ga14f7d5c+4,17.0.1-17-gc79d625+1,17.0.1-17-gdae4c4a+8,17.0.1-2-g26618f5+29,17.0.1-2-g54f2ebc+9,17.0.1-2-gf403422+1,17.0.1-20-g2ca2f74+6,17.0.1-23-gf3eadeb7+1,17.0.1-3-g7e86b59+39,17.0.1-3-gb5ca14a,17.0.1-3-gd08d533+40,17.0.1-30-g596af8797,17.0.1-4-g59d126d+4,17.0.1-4-gc69c472+5,17.0.1-6-g5afd9b9+4,17.0.1-7-g35889ee+1,17.0.1-7-gc7c8782+18,17.0.1-9-gc4bbfb2+3,w.2019.22
LSSTDataManagementBasePackage
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 
9 namespace lsst {
10 namespace afw {
11 namespace table {
12 
13 namespace detail {
14 
16 struct FlagExtractor {
18  typedef bool result_type;
19 
20  result_type operator()(argument_type element) const { return element & _mask; }
21 
22  explicit FlagExtractor(Key<Flag> const& key) : _mask(argument_type(1) << key.getBit()) {}
23 
24 private:
25  argument_type _mask;
26 };
27 
28 } // namespace detail
29 
30 class BaseTable;
31 
32 class BaseColumnView;
33 
42 class BitsColumn final {
43 public:
44  typedef std::int64_t IntT;
45 
46  ndarray::Array<IntT, 1, 1> getArray() const { return _array; }
47 
48  IntT getBit(Key<Flag> const& key) const;
49  IntT getBit(std::string const& name) const;
50 
51  IntT getMask(Key<Flag> const& key) const { return IntT(1) << getBit(key); }
52  IntT getMask(std::string const& name) const { return IntT(1) << getBit(name); }
53 
54  std::vector<SchemaItem<Flag> > const& getSchemaItems() const { return _items; }
55 
56 private:
57  friend class BaseColumnView;
58 
59  explicit BitsColumn(int size);
60 
61  ndarray::Array<IntT, 1, 1> _array;
63 };
64 
84 public:
86  std::shared_ptr<BaseTable> getTable() const;
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 
117  BitsColumn getBits(std::vector<Key<Flag> > const& keys) const;
118 
127  BitsColumn getAllBits() const;
128 
135  template <typename InputIterator>
136  static BaseColumnView make(std::shared_ptr<BaseTable> const& table, InputIterator first,
137  InputIterator last);
138 
146  template <typename InputIterator>
147  static bool isRangeContiguous(std::shared_ptr<BaseTable> const& table, InputIterator first,
148  InputIterator last);
149 
152  BaseColumnView& operator=(BaseColumnView const&);
153  BaseColumnView& operator=(BaseColumnView&&);
154 
155  ~BaseColumnView();
156 
157 protected:
158  BaseColumnView(std::shared_ptr<BaseTable> const& table, int recordCount, void* buf,
159  ndarray::Manager::Ptr const& manager);
160 
161 private:
162  friend class BaseTable;
163 
164  struct Impl;
165 
166  std::shared_ptr<Impl> _impl;
167 };
168 
169 template <typename RecordT>
170 class ColumnViewT : public BaseColumnView {
171 public:
172  typedef RecordT Record;
173  typedef typename RecordT::Table Table;
174 
178  }
179 
181  template <typename InputIterator>
182  static ColumnViewT make(std::shared_ptr<Table> const& table, InputIterator first, InputIterator last) {
183  return ColumnViewT(BaseColumnView::make(table, first, last));
184  }
185 
186  ColumnViewT(ColumnViewT const&) = default;
187  ColumnViewT(ColumnViewT&&) = default;
188  ColumnViewT& operator=(ColumnViewT const&) = default;
189  ColumnViewT& operator=(ColumnViewT&&) = default;
190  ~ColumnViewT() = default;
191 
192 protected:
193  explicit ColumnViewT(BaseColumnView const& base) : BaseColumnView(base) {}
194 };
195 
196 template <typename InputIterator>
198  InputIterator last) {
199  if (first == last) {
200  return BaseColumnView(table, 0, 0, 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 }
216 
217 template <typename InputIterator>
219  InputIterator last) {
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 }
234 } // namespace table
235 } // namespace afw
236 } // namespace lsst
237 
238 #endif // !AFW_TABLE_BaseColumnView_h_INCLUDED
Defines the fields and offsets for a table.
Definition: Schema.h:50
ndarray::Array< IntT, 1, 1 > getArray() const
int getRecordSize() const
Return the raw size of a record in bytes.
Definition: Schema.h:148
Column-wise view into a sequence of records that have been allocated contiguously.
A packed representation of a collection of Flag field columns.
std::shared_ptr< BaseTable > getTable() const
Return the table that owns the records.
IntT getMask(std::string const &name) const
static ColumnViewT make(std::shared_ptr< Table > const &table, InputIterator first, InputIterator last)
Construct a BaseColumnView from an iterator range.
ColumnViewT(BaseColumnView const &base)
Schema getSchema() const
Return the schema that defines the fields.
STL class.
double element[2]
Definition: BaseTable.cc:91
Functor to compute a flag bit, used to create an ndarray expression template for flag columns...
A base class for image defects.
table::Key< int > type
Definition: Detector.cc:167
static BaseColumnView make(std::shared_ptr< BaseTable > const &table, InputIterator first, InputIterator last)
Construct a BaseColumnView from an iterator range.
std::shared_ptr< Table > getTable() const
Return the table that owns the records.
A description of a field in a table.
Definition: Field.h:24
table::Schema schema
Definition: Camera.cc:161
Tag types used to declare specialized field types.
Definition: misc.h:32
T static_pointer_cast(T... args)
#define LSST_EXCEPT(type,...)
Create an exception with a given type.
Definition: Exception.h:48
STL class.
A class used as a handle to a particular field in a table.
Definition: fwd.h:45
Key< U > key
Definition: Schema.cc:281
Key specialization for Flag.
Definition: Flag.h:94
result_type operator()(argument_type element) const
IntT getMask(Key< Flag > const &key) const
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 ...
std::vector< SchemaItem< Flag > > const & getSchemaItems() const
FlagExtractor(Key< Flag > const &key)
Base class for all tables.
Definition: BaseTable.h:61
Reports errors that are due to events beyond the control of the program.
Definition: Runtime.h:104