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
BaseRecord.h
Go to the documentation of this file.
1 // -*- lsst-c++ -*-
2 #ifndef AFW_TABLE_BaseRecord_h_INCLUDED
3 #define AFW_TABLE_BaseRecord_h_INCLUDED
4 
5 #include <iosfwd>
6 
7 #include "lsst/base.h"
8 #include "lsst/afw/table/fwd.h"
12 
13 namespace lsst {
14 namespace afw {
15 namespace table {
16 
31 class BaseRecord {
32 protected:
33 
34  // Protected class whose instances must be passed to the public
35  // constructor, providing more fine-grained access control than a
36  // protected constructor would. In particular, this allows make_shared to
37  // be used.
39  private:
40  friend class BaseTable;
41 
42  // A private ctor for this class (and friendship) is necessary to
43  // prevent e.g. BaseRecord({}, ...) calls from code without access
44  // to ConstructionToken.
45  explicit ConstructionToken(int) noexcept {}
46  };
47 
48 public:
49 
58  BaseRecord(ConstructionToken const &, detail::RecordData && data);
59  // No copying
60  BaseRecord(const BaseRecord&) = delete;
61  BaseRecord& operator=(const BaseRecord&) = delete;
62 
63  // No moving
64  BaseRecord(BaseRecord&&) = delete;
66 
68  using Table = BaseTable;
69 
72 
75 
78 
80  Schema getSchema() const { return _table->getSchema(); }
81 
83  std::shared_ptr<BaseTable const> getTable() const { return _table; }
84 
92  template <typename T>
93  typename Field<T>::Element* getElement(Key<T> const& key) {
94  if (!key.isValid()) {
95  throw LSST_EXCEPT(
97  "Key is not valid (if this is a SourceRecord, make sure slot aliases have been set up).");
98  }
99  return reinterpret_cast<typename Field<T>::Element*>(reinterpret_cast<char*>(_data) +
100  key.getOffset());
101  }
102 
110  template <typename T>
111  typename Field<T>::Element const* getElement(Key<T> const& key) const {
112  if (!key.isValid()) {
113  throw LSST_EXCEPT(
115  "Key is not valid (if this is a SourceRecord, make sure slot aliases have been set up).");
116  }
117  return reinterpret_cast<typename Field<T>::Element const*>(reinterpret_cast<char const*>(_data) +
118  key.getOffset());
119  }
120 
128  template <typename T>
129  typename Field<T>::Reference operator[](Key<T> const& key) {
130  return key.getReference(getElement(key), _manager);
131  }
132 
140  template <typename T>
141  typename Field<T>::ConstReference operator[](Key<T> const& key) const {
142  return key.getConstReference(getElement(key), _manager);
143  }
144 
150  template <typename T>
151  typename Field<T>::Value get(Key<T> const& key) const {
152  return key.getValue(getElement(key), _manager);
153  }
154 
163  template <typename T, typename U>
164  void set(Key<T> const& key, U const& value) {
165  key.setValue(getElement(key), _manager, value);
166  }
167 
171  template <typename T>
172  T get(OutputFunctorKey<T> const& key) const {
173  return key.get(*this);
174  }
175 
179  template <typename T, typename U>
180  void set(InputFunctorKey<T> const& key, U const& value) {
181  return key.set(*this, value);
182  }
183 
184  template <typename Ref>
186  return key.getReference(*this);
187  }
188 
189  template <typename ConstRef>
190  ConstRef operator[](ConstReferenceFunctorKey<ConstRef> const& key) const {
191  return key.getConstReference(*this);
192  }
193 
195  void assign(BaseRecord const& other);
196 
198  void assign(BaseRecord const& other, SchemaMapper const& mapper);
199 
200  ndarray::Manager::Ptr getManager() const { return _manager; }
201 
202  virtual ~BaseRecord() { _table->_destroy(*this); }
203 
205  friend std::ostream& operator<<(std::ostream& os, BaseRecord const& record);
206 
207 protected:
209  virtual void _assign(BaseRecord const& other) {}
210 
213  virtual void _stream(std::ostream& os) const;
214 
215 
216 private:
217  friend class BaseTable;
218  friend class BaseColumnView;
219 
220  // All these are definitely private, not protected - we don't want derived classes mucking with them.
221  void* _data; // pointer to field data
222  std::shared_ptr<BaseTable> _table; // the associated table
223  ndarray::Manager::Ptr _manager; // shared manager for lifetime of _data (like shared_ptr with no pointer)
224 };
225 
226 template <typename RecordT, typename ...Args>
228  return std::make_shared<RecordT>(BaseRecord::ConstructionToken(0), _makeNewRecordData(),
229  std::forward<Args>(args)...);
230 }
231 
232 
233 } // namespace table
234 } // namespace afw
235 } // namespace lsst
236 
237 #endif // !AFW_TABLE_BaseRecord_h_INCLUDED
char * data
Definition: BaseRecord.cc:61
#define LSST_EXCEPT(type,...)
Create an exception with a given type.
Definition: Exception.h:48
std::ostream * os
Definition: Schema.cc:557
SchemaMapper * mapper
Definition: SchemaMapper.cc:71
Basic LSST definitions.
Column-wise view into a sequence of records that have been allocated contiguously.
Base class for all records.
Definition: BaseRecord.h:31
Ref operator[](ReferenceFunctorKey< Ref > const &key)
Definition: BaseRecord.h:185
BaseRecord & operator=(BaseRecord &&)=delete
Field< T >::Element const * getElement(Key< T > const &key) const
Return a pointer to the underlying elements of a field (const).
Definition: BaseRecord.h:111
void assign(BaseRecord const &other)
Copy all field values from other to this, requiring that they have equal schemas.
Definition: BaseRecord.cc:122
ConstRef operator[](ConstReferenceFunctorKey< ConstRef > const &key) const
Definition: BaseRecord.h:190
BaseRecord & operator=(const BaseRecord &)=delete
friend std::ostream & operator<<(std::ostream &os, BaseRecord const &record)
Write the record's content out, one field on each line.
Definition: BaseRecord.cc:158
BaseRecord(BaseRecord &&)=delete
Field< T >::Reference operator[](Key< T > const &key)
Return a reference (or reference-like type) to the field's value.
Definition: BaseRecord.h:129
Schema getSchema() const
Return the Schema that holds this record's fields and keys.
Definition: BaseRecord.h:80
Field< T >::ConstReference operator[](Key< T > const &key) const
Return a const reference (or const-reference-like type) to the field's value.
Definition: BaseRecord.h:141
ndarray::Manager::Ptr getManager() const
Definition: BaseRecord.h:200
void set(InputFunctorKey< T > const &key, U const &value)
Set a calculated or aggregate field.
Definition: BaseRecord.h:180
BaseRecord(const BaseRecord &)=delete
Field< T >::Element * getElement(Key< T > const &key)
Return a pointer to the underlying elements of a field (non-const).
Definition: BaseRecord.h:93
BaseRecord(ConstructionToken const &, detail::RecordData &&data)
Construct a record with uninitialized data.
Definition: BaseRecord.cc:143
void set(Key< T > const &key, U const &value)
Set value of a field for the given key.
Definition: BaseRecord.h:164
Field< T >::Value get(Key< T > const &key) const
Return the value of a field for the given key.
Definition: BaseRecord.h:151
T get(OutputFunctorKey< T > const &key) const
Compute a calculated or aggregate field.
Definition: BaseRecord.h:172
virtual void _assign(BaseRecord const &other)
Called by assign() after transferring fields to allow subclass data members to be copied.
Definition: BaseRecord.h:209
virtual void _stream(std::ostream &os) const
Called by operator<<.
Definition: BaseRecord.cc:152
std::shared_ptr< BaseTable const > getTable() const
Return the table this record is associated with.
Definition: BaseRecord.h:83
Base class for all tables.
Definition: BaseTable.h:61
std::shared_ptr< RecordT > constructRecord(Args &&...args)
Helper function that must be used by all _makeRecord overrides to actually construct records.
Definition: BaseRecord.h:227
Base class for objects that can return a const reference to part of a record, but are not a true Key.
Definition: FunctorKey.h:109
virtual T getConstReference(BaseRecord const &record) const =0
Base class for objects that can set a value on a record, but are not a true Key themselves.
Definition: FunctorKey.h:57
virtual void set(BaseRecord &record, T const &value) const =0
A class used as a handle to a particular field in a table.
Definition: Key.h:53
std::size_t getOffset() const noexcept
Return the offset (in bytes) of this field within a record.
Definition: Key.h:87
bool isValid() const noexcept
Return true if the key was initialized to valid offset.
Definition: Key.h:97
Base class for objects that can extract a value from a record, but are not a true Key themselves.
Definition: FunctorKey.h:40
virtual T get(BaseRecord const &record) const =0
Base class for objects that can return a non-const reference to part of a record, but are not a true ...
Definition: FunctorKey.h:91
virtual T getReference(BaseRecord &record) const =0
Defines the fields and offsets for a table.
Definition: Schema.h:51
A mapping between the keys of two Schemas, used to copy data between them.
Definition: SchemaMapper.h:21
Reports errors in the logical structure of the program.
Definition: Runtime.h:46
A base class for image defects.
const T & ConstReference
the type returned by BaseRecord::operator[] (const)
Definition: FieldBase.h:44
ConstReference getConstReference(Element const *p, ndarray::Manager::Ptr const &) const
Used to implement BaseRecord::operator[] (const).
Definition: FieldBase.h:78
Value getValue(Element const *p, ndarray::Manager::Ptr const &) const
Used to implement BaseRecord::get.
Definition: FieldBase.h:81
T & Reference
the type returned by BaseRecord::operator[] (non-const)
Definition: FieldBase.h:43
void setValue(Element *p, ndarray::Manager::Ptr const &, Value v) const
Used to implement BaseRecord::set.
Definition: FieldBase.h:84
Reference getReference(Element *p, ndarray::Manager::Ptr const &) const
Used to implement BaseRecord::operator[] (non-const).
Definition: FieldBase.h:75
T Value
the type returned by BaseRecord::get
Definition: FieldBase.h:42
typename FieldBase< T >::Element Element
Type used to store field data in the table (a field may have multiple elements).
Definition: Field.h:26
Helper struct that contains the information passed from BaseTable to BaseRecord at construction.
Definition: BaseTable.h:32