LSST Applications g042eb84c57+730a74494b,g04e9c324dd+8c5ae1fdc5,g134cb467dc+1f1e3e7524,g199a45376c+0ba108daf9,g1fd858c14a+fa7d31856b,g210f2d0738+f66ac109ec,g262e1987ae+83a3acc0e5,g29ae962dfc+d856a2cb1f,g2cef7863aa+aef1011c0b,g35bb328faa+8c5ae1fdc5,g3fd5ace14f+a1e0c9f713,g47891489e3+0d594cb711,g4d44eb3520+c57ec8f3ed,g4d7b6aa1c5+f66ac109ec,g53246c7159+8c5ae1fdc5,g56a1a4eaf3+fd7ad03fde,g64539dfbff+f66ac109ec,g67b6fd64d1+0d594cb711,g67fd3c3899+f66ac109ec,g6985122a63+0d594cb711,g74acd417e5+3098891321,g786e29fd12+668abc6043,g81db2e9a8d+98e2ab9f28,g87389fa792+8856018cbb,g89139ef638+0d594cb711,g8d7436a09f+80fda9ce03,g8ea07a8fe4+760ca7c3fc,g90f42f885a+033b1d468d,g97be763408+a8a29bda4b,g99822b682c+e3ec3c61f9,g9d5c6a246b+0d5dac0c3d,ga41d0fce20+9243b26dd2,gbf99507273+8c5ae1fdc5,gd7ef33dd92+0d594cb711,gdab6d2f7ff+3098891321,ge410e46f29+0d594cb711,geaed405ab2+c4bbc419c6,gf9a733ac38+8c5ae1fdc5,w.2025.38
LSST Data Management Base Package
Loading...
Searching...
No Matches
BaseTable.h
Go to the documentation of this file.
1// -*- lsst-c++ -*-
2#ifndef AFW_TABLE_BaseTable_h_INCLUDED
3#define AFW_TABLE_BaseTable_h_INCLUDED
4#include <memory>
5
6#include "lsst/base.h"
7#include "ndarray/Manager.h"
10
11namespace lsst {
12namespace afw {
13
14namespace fits {
15
16class Fits;
17
18} // namespace fits
19
20namespace table {
21
22namespace detail {
23
32struct RecordData {
33 void* data;
35 ndarray::Manager::Ptr manager;
36};
37
38} // namespace detail
39
61class BaseTable : public std::enable_shared_from_this<BaseTable> {
62public:
65
68
71
74
76 static int nRecordsPerBlock;
77
80
82 void setMetadata(std::shared_ptr<daf::base::PropertyList> const& metadata) { _metadata = metadata; }
83
90
101
109
128
135
137 Schema getSchema() const { return _schema; }
138
151 void preallocate(std::size_t nRecords);
152
159
172 static std::shared_ptr<BaseTable> make(Schema const& schema);
173
179 static Schema makeMinimalSchema();
180
181 // Tables are not assignable to prevent type slicing.
182 BaseTable& operator=(BaseTable const& other) = delete;
183 BaseTable& operator=(BaseTable&& other) = delete;
184
185 virtual ~BaseTable();
186
187protected:
202 // n.b. this is implemented in BaseRecord.h, as it requires the BaseRecord
203 // definition, and must go in a header.
204 template <typename RecordT, typename... Args>
206
207 virtual void handleAliasChange(std::string const& alias) {}
208
210 virtual std::shared_ptr<BaseTable> _clone() const;
211
214
216 explicit BaseTable(Schema const& schema, std::shared_ptr<daf::base::PropertyList> metadata = nullptr);
217
218 BaseTable(BaseTable const& other);
219 BaseTable(BaseTable&& other) = delete;
220
221private:
222 friend class BaseRecord;
223 friend class io::FitsWriter;
224 friend class AliasMap;
225
226 // Obtain raw data pointers and their managing objects for a new record.
227 detail::RecordData _makeNewRecordData();
228
229 /*
230 * Called by BaseRecord dtor to notify the table when it is about to be destroyed.
231 *
232 * This could allow the table to reclaim that space, but that requires more bookkeeping than
233 * it's presently worth unless this was the most recently allocated record.
234 *
235 * The motivation for attempting to reclaim even some memory is not because we're paranoid
236 * about using every last bit of allocated memory efficiently - it's so we can keep
237 * records contiguous as much as possible to allow ColumnView to be used.
238 */
239 void _destroy(BaseRecord& record);
240
241 // Return a writer object that knows how to save in FITS format. See also FitsWriter.
242 virtual std::shared_ptr<io::FitsWriter> makeFitsWriter(fits::Fits* fitsfile, int flags) const;
243
244 // All these are definitely private, not protected - we don't want derived classes mucking with them.
245 Schema _schema; // schema that defines the table's fields
246 ndarray::Manager::Ptr _manager; // current memory block to use for new records
247 std::shared_ptr<daf::base::PropertyList> _metadata; // flexible metadata; may be null
248};
249
250} // namespace table
251} // namespace afw
252} // namespace lsst
253
254#endif // !AFW_TABLE_BaseTable_h_INCLUDED
Basic LSST definitions.
A simple struct that combines the two arguments that must be passed to most cfitsio routines and cont...
Definition fits.h:308
Column-wise view into a sequence of records that have been allocated contiguously.
Base class for all records.
Definition BaseRecord.h:31
Base class for all tables.
Definition BaseTable.h:61
void setMetadata(std::shared_ptr< daf::base::PropertyList > const &metadata)
Set the flexible metadata associated with the table. May be null.
Definition BaseTable.h:82
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
CatalogT< const Record > ConstCatalog
Template of CatalogT used to hold const records of the associated type.
Definition BaseTable.h:73
virtual std::shared_ptr< BaseRecord > _makeRecord()
Default-construct an associated record (protected implementation).
Definition BaseTable.cc:150
BaseTable & operator=(BaseTable const &other)=delete
std::shared_ptr< daf::base::PropertyList > popMetadata()
Return the metadata and set the internal metadata to a null pointer.
Definition BaseTable.h:85
virtual std::shared_ptr< io::FitsWriter > makeFitsWriter(fits::Fits *fitsfile, int flags) const
Definition BaseTable.cc:140
Schema getSchema() const
Return the table's schema.
Definition BaseTable.h:137
CatalogT< Record > Catalog
Template of CatalogT used to hold records of the associated type.
Definition BaseTable.h:70
void preallocate(std::size_t nRecords)
Allocate contiguous space for new records in advance.
Definition BaseTable.cc:110
BaseTable & operator=(BaseTable &&other)=delete
std::shared_ptr< daf::base::PropertyList > getMetadata() const
Return the flexible metadata associated with the table. May be null.
Definition BaseTable.h:79
BaseColumnView ColumnView
The associated ColumnView class.
Definition BaseTable.h:67
BaseTable(BaseTable &&other)=delete
std::shared_ptr< BaseRecord > copyRecord(BaseRecord const &input)
Deep-copy a record, requiring that it have the same schema as this table.
Definition BaseTable.cc:128
std::shared_ptr< BaseTable > clone() const
Return a polymorphic deep copy of the table.
Definition BaseTable.h:100
BaseTable(Schema const &schema, std::shared_ptr< daf::base::PropertyList > metadata=nullptr)
Construct from a schema.
Definition BaseTable.cc:152
std::size_t getBufferSize() const
Return the number of additional records space has been already been allocated for.
Definition BaseTable.cc:112
static Schema makeMinimalSchema()
Return a minimal schema for Base tables and records.
Definition BaseTable.cc:126
static int nRecordsPerBlock
Number of records in each memory block.
Definition BaseTable.h:76
static std::shared_ptr< BaseTable > make(Schema const &schema)
Construct a new table.
Definition BaseTable.cc:120
virtual void handleAliasChange(std::string const &alias)
Definition BaseTable.h:207
BaseRecord Record
The associated record class.
Definition BaseTable.h:64
virtual std::shared_ptr< BaseTable > _clone() const
Clone implementation with noncovariant return types.
Definition BaseTable.cc:144
std::shared_ptr< BaseRecord > makeRecord()
Default-construct an associated record.
Definition BaseTable.h:108
A custom container class for records, based on std::vector.
Definition Catalog.h:98
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.
Writer object for FITS binary tables.
Definition FitsWriter.h:25
Helper struct that contains the information passed from BaseTable to BaseRecord at construction.
Definition BaseTable.h:32
ndarray::Manager::Ptr manager
Definition BaseTable.h:35
std::shared_ptr< BaseTable > table
Definition BaseTable.h:34
T swap(T... args)