LSST Applications g0265f82a02+c6dfa2ddaf,g1162b98a3f+ffe7eabc7e,g2079a07aa2+1b2e822518,g2bbee38e9b+c6dfa2ddaf,g337abbeb29+c6dfa2ddaf,g36da64cc00+ea84795170,g3ddfee87b4+955a963fd8,g50ff169b8f+2eb0e556e8,g52b1c1532d+90ebb246c7,g555ede804d+955a963fd8,g591dd9f2cf+bac198a2cb,g5ec818987f+420292cfeb,g858d7b2824+d6c9a0a3b8,g876c692160+aabc49a3c3,g8a8a8dda67+90ebb246c7,g8cdfe0ae6a+4fd9e222a8,g99cad8db69+e6cd765486,g9ddcbc5298+a1346535a5,ga1e77700b3+df8f93165b,ga8c6da7877+acd47f83f4,gae46bcf261+c6dfa2ddaf,gb0e22166c9+8634eb87fb,gb3f2274832+12c8382528,gba4ed39666+1ac82b564f,gbb8dafda3b+0574160a1f,gbeb006f7da+dea2fbb49f,gc28159a63d+c6dfa2ddaf,gc86a011abf+d6c9a0a3b8,gcf0d15dbbd+955a963fd8,gdaeeff99f8+1cafcb7cd4,gdc0c513512+d6c9a0a3b8,ge79ae78c31+c6dfa2ddaf,geb67518f79+ba1859f325,gee10cc3b42+90ebb246c7,gf1cff7945b+d6c9a0a3b8,w.2024.13
LSST Data Management Base Package
Loading...
Searching...
No Matches
Public Types | Public Member Functions | Static Public Member Functions | Static Public Attributes | Protected Member Functions | Private Member Functions | Friends | List of all members
lsst::afw::table::SimpleTable Class Reference

Table class that must contain a unique ID field and a celestial coordinate field. More...

#include <Simple.h>

Inheritance diagram for lsst::afw::table::SimpleTable:
lsst::afw::table::BaseTable std::enable_shared_from_this< BaseTable > lsst::afw::table::SourceTable

Public Types

using Record = SimpleRecord
 
using ColumnView = ColumnViewT<SimpleRecord>
 
using Catalog = SortedCatalogT<Record>
 
using ConstCatalog = SortedCatalogT<const Record>
 

Public Member Functions

std::shared_ptr< IdFactorygetIdFactory ()
 Return the object that generates IDs for the table (may be null).
 
std::shared_ptr< IdFactory constgetIdFactory () const
 Return the object that generates IDs for the table (may be null).
 
void setIdFactory (std::shared_ptr< IdFactory > f)
 Switch to a new IdFactory – object that generates IDs for the table (may be null).
 
std::shared_ptr< SimpleTableclone () const
 Return a polymorphic deep copy of the table.
 
std::shared_ptr< SimpleRecordmakeRecord ()
 Default-construct an associated record.
 
std::shared_ptr< SimpleRecordcopyRecord (BaseRecord const &other)
 Deep-copy a record, requiring that it have the same schema as this table.
 
std::shared_ptr< SimpleRecordcopyRecord (BaseRecord const &other, SchemaMapper const &mapper)
 Deep-copy a record, requiring that it have the same schema as this table.
 
SimpleTableoperator= (SimpleTable const &)=delete
 
SimpleTableoperator= (SimpleTable &&)=delete
 
 ~SimpleTable () override
 
std::shared_ptr< daf::base::PropertyListgetMetadata () const
 Return the flexible metadata associated with the table. May be null.
 
void setMetadata (std::shared_ptr< daf::base::PropertyList > const &metadata)
 Set the flexible metadata associated with the table. May be null.
 
std::shared_ptr< daf::base::PropertyListpopMetadata ()
 Return the metadata and set the internal metadata to a null pointer.
 
Schema getSchema () const
 Return the table's schema.
 
void preallocate (std::size_t nRecords)
 Allocate contiguous space for new records in advance.
 
std::size_t getBufferSize () const
 Return the number of additional records space has been already been allocated for.
 
shared_from_this (T... args)
 

Static Public Member Functions

static std::shared_ptr< SimpleTablemake (Schema const &schema, std::shared_ptr< IdFactory > const &idFactory)
 Construct a new table.
 
static std::shared_ptr< SimpleTablemake (Schema const &schema)
 Construct a new table.
 
static Schema makeMinimalSchema ()
 Return a minimal schema for Simple tables and records.
 
static bool checkSchema (Schema const &other)
 Return true if the given schema is a valid SimpleTable schema.
 
static Key< RecordIdgetIdKey ()
 Get keys for standard fields shared by all references.
 
static CoordKey getCoordKey ()
 Key for the celestial coordinates.
 

Static Public Attributes

static int nRecordsPerBlock = 100
 Number of records in each memory block.
 

Protected Member Functions

 SimpleTable (Schema const &schema, std::shared_ptr< IdFactory > const &idFactory)
 
 SimpleTable (SimpleTable const &other)
 
 SimpleTable (SimpleTable &&other)
 
std::shared_ptr< BaseTable_clone () const override
 Clone implementation with noncovariant return types.
 
std::shared_ptr< BaseRecord_makeRecord () override
 Default-construct an associated record (protected implementation).
 
template<typename RecordT , typename... Args>
std::shared_ptr< RecordTconstructRecord (Args &&... args)
 Helper function that must be used by all _makeRecord overrides to actually construct records.
 
virtual void handleAliasChange (std::string const &alias)
 

Private Member Functions

std::shared_ptr< io::FitsWritermakeFitsWriter (fits::Fits *fitsfile, int flags) const override
 

Friends

class io::FitsWriter
 

Detailed Description

Table class that must contain a unique ID field and a celestial coordinate field.

SimpleTable / SimpleRecord are intended to be the base class for records representing astronomical objects. In additional to the minimal schema and the convenience accessors it allows, a SimpleTable may hold an IdFactory object that is used to assign unique IDs to new records.

Definition at line 102 of file Simple.h.

Member Typedef Documentation

◆ Catalog

Definition at line 106 of file Simple.h.

◆ ColumnView

Definition at line 105 of file Simple.h.

◆ ConstCatalog

Definition at line 107 of file Simple.h.

◆ Record

Definition at line 104 of file Simple.h.

Constructor & Destructor Documentation

◆ ~SimpleTable()

lsst::afw::table::SimpleTable::~SimpleTable ( )
overridedefault

◆ SimpleTable() [1/3]

lsst::afw::table::SimpleTable::SimpleTable ( Schema const & schema,
std::shared_ptr< IdFactory > const & idFactory )
protected

Definition at line 84 of file Simple.cc.

85 : BaseTable(schema, std::make_shared<daf::base::PropertyList>()), _idFactory(idFactory) {}
BaseTable(Schema const &schema, std::shared_ptr< daf::base::PropertyList > metadata=nullptr)
Construct from a schema.
Definition BaseTable.cc:148

◆ SimpleTable() [2/3]

lsst::afw::table::SimpleTable::SimpleTable ( SimpleTable const & other)
explicitprotected

Definition at line 87 of file Simple.cc.

88 : BaseTable(other), _idFactory(other._idFactory ? other._idFactory->clone() : other._idFactory) {}

◆ SimpleTable() [3/3]

lsst::afw::table::SimpleTable::SimpleTable ( SimpleTable && other)
explicitprotected

Definition at line 90 of file Simple.cc.

90: SimpleTable(other) {}
SimpleTable(Schema const &schema, std::shared_ptr< IdFactory > const &idFactory)
Definition Simple.cc:84

Member Function Documentation

◆ _clone()

std::shared_ptr< BaseTable > lsst::afw::table::SimpleTable::_clone ( ) const
overrideprotectedvirtual

Clone implementation with noncovariant return types.

Reimplemented from lsst::afw::table::BaseTable.

Reimplemented in lsst::afw::table::SourceTable.

Definition at line 108 of file Simple.cc.

108 {
109 return std::shared_ptr<SimpleTable>(new SimpleTable(*this));
110}

◆ _makeRecord()

std::shared_ptr< BaseRecord > lsst::afw::table::SimpleTable::_makeRecord ( )
overrideprotectedvirtual

Default-construct an associated record (protected implementation).

Reimplemented from lsst::afw::table::BaseTable.

Reimplemented in lsst::afw::table::SourceTable.

Definition at line 112 of file Simple.cc.

112 {
113 auto record = constructRecord<SimpleRecord>();
114 if (getIdFactory()) record->setId((*getIdFactory())());
115 return record;
116}
std::shared_ptr< IdFactory > getIdFactory()
Return the object that generates IDs for the table (may be null).
Definition Simple.h:155

◆ checkSchema()

static bool lsst::afw::table::SimpleTable::checkSchema ( Schema const & other)
inlinestatic

Return true if the given schema is a valid SimpleTable schema.

This will always be true if the given schema was originally constructed using makeMinimalSchema(), and will rarely be true otherwise.

Definition at line 152 of file Simple.h.

152{ return other.contains(getMinimalSchema().schema); }

◆ clone()

std::shared_ptr< SimpleTable > lsst::afw::table::SimpleTable::clone ( ) const
inline

Return a polymorphic deep copy of the table.

Derived classes should reimplement by static-casting the output of _clone to a pointer-to-derived to simulate covariant return types.

Cloning a table does not clone its associated records; the new table produced by clone() does not have any associated records.

Definition at line 176 of file Simple.h.

176{ return std::static_pointer_cast<SimpleTable>(_clone()); }
std::shared_ptr< BaseTable > _clone() const override
Clone implementation with noncovariant return types.
Definition Simple.cc:108

◆ constructRecord()

template<typename RecordT , typename ... Args>
std::shared_ptr< RecordT > lsst::afw::table::BaseTable::constructRecord ( Args &&... args)
protectedinherited

Helper function that must be used by all _makeRecord overrides to actually construct records.

Use of this function is enforced by the fact that Record::ConstructionToken can only be created by BaseTable, and is only ever constructed inside this method.

This function expects Record subclasses to have a constructor signature of the form

Record(ConstructionToken const &, detail::RecordData &&, Args && ...);

Definition at line 227 of file BaseRecord.h.

227 {
228 return std::make_shared<RecordT>(BaseRecord::ConstructionToken(0), _makeNewRecordData(),
229 std::forward<Args>(args)...);
230}

◆ copyRecord() [1/2]

std::shared_ptr< SimpleRecord > lsst::afw::table::SimpleTable::copyRecord ( BaseRecord const & other)
inline

Deep-copy a record, requiring that it have the same schema as this table.

Regardless of the type or associated table of the input record, the type of the output record will be the type associated with this table and the record instance will be associated with this table.

Allowing derived-class records to be constructed from base-class records could be considered a form of type-slicing, but because we already demand that all records be constructable from nothing but a table, this isn't anything new.

Derived classes should reimplement by static-casting the output of BaseTable::copyRecord to the appropriate BaseRecord subclass.

This is implemented using makeRecord and calling record.assign on the results; override those to change the behavior.

Definition at line 184 of file Simple.h.

184 {
185 return std::static_pointer_cast<SimpleRecord>(BaseTable::copyRecord(other));
186 }
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:126

◆ copyRecord() [2/2]

std::shared_ptr< SimpleRecord > lsst::afw::table::SimpleTable::copyRecord ( BaseRecord const & other,
SchemaMapper const & mapper )
inline

Deep-copy a record, requiring that it have the same schema as this table.

Regardless of the type or associated table of the input record, the type of the output record will be the type associated with this table and the record instance will be associated with this table.

Allowing derived-class records to be constructed from base-class records could be considered a form of type-slicing, but because we already demand that all records be constructable from nothing but a table, this isn't anything new.

Derived classes should reimplement by static-casting the output of BaseTable::copyRecord to the appropriate BaseRecord subclass.

This is implemented using makeRecord and calling record.assign on the results; override those to change the behavior.

Definition at line 189 of file Simple.h.

189 {
190 return std::static_pointer_cast<SimpleRecord>(BaseTable::copyRecord(other, mapper));
191 }
SchemaMapper * mapper

◆ getBufferSize()

std::size_t lsst::afw::table::BaseTable::getBufferSize ( ) const
inherited

Return the number of additional records space has been already been allocated for.

Unlike std::vector::capacity, this does not factor in existing records in any way.

Definition at line 112 of file BaseTable.cc.

112 {
113 if (_manager) {
114 return Block::getBufferSize(_schema.getRecordSize(), _manager);
115 } else {
116 return 0;
117 }
118}
std::size_t getRecordSize() const
Return the raw size of a record in bytes.
Definition Schema.h:149

◆ getCoordKey()

static CoordKey lsst::afw::table::SimpleTable::getCoordKey ( )
inlinestatic

Key for the celestial coordinates.

Definition at line 172 of file Simple.h.

172{ return getMinimalSchema().coord; }

◆ getIdFactory() [1/2]

std::shared_ptr< IdFactory > lsst::afw::table::SimpleTable::getIdFactory ( )
inline

Return the object that generates IDs for the table (may be null).

Definition at line 155 of file Simple.h.

155{ return _idFactory; }

◆ getIdFactory() [2/2]

std::shared_ptr< IdFactory const > lsst::afw::table::SimpleTable::getIdFactory ( ) const
inline

Return the object that generates IDs for the table (may be null).

Definition at line 158 of file Simple.h.

158{ return _idFactory; }

◆ getIdKey()

static Key< RecordId > lsst::afw::table::SimpleTable::getIdKey ( )
inlinestatic

Get keys for standard fields shared by all references.

These keys are used to implement getters and setters on SimpleRecord. Key for the unique ID.

Definition at line 170 of file Simple.h.

170{ return getMinimalSchema().id; }

◆ getMetadata()

std::shared_ptr< daf::base::PropertyList > lsst::afw::table::BaseTable::getMetadata ( ) const
inlineinherited

Return the flexible metadata associated with the table. May be null.

Definition at line 79 of file BaseTable.h.

79{ return _metadata; }

◆ getSchema()

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

Return the table's schema.

Definition at line 137 of file BaseTable.h.

137{ return _schema; }

◆ handleAliasChange()

virtual void lsst::afw::table::BaseTable::handleAliasChange ( std::string const & alias)
inlineprotectedvirtualinherited

Reimplemented in lsst::afw::table::SourceTable.

Definition at line 207 of file BaseTable.h.

207{}

◆ make() [1/2]

static std::shared_ptr< SimpleTable > lsst::afw::table::SimpleTable::make ( Schema const & schema)
inlinestatic

Construct a new table.

Parameters
[in]schemaSchema that defines the fields, offsets, and record size for the table.

This overload sets the ID factory to IdFactory::makeSimple().

Definition at line 129 of file Simple.h.

129 {
130 return make(schema, IdFactory::makeSimple());
131 }
static std::shared_ptr< IdFactory > makeSimple()
Return a simple IdFactory that simply counts from 1.
Definition IdFactory.cc:70
static std::shared_ptr< SimpleTable > make(Schema const &schema, std::shared_ptr< IdFactory > const &idFactory)
Construct a new table.
Definition Simple.cc:75

◆ make() [2/2]

std::shared_ptr< SimpleTable > lsst::afw::table::SimpleTable::make ( Schema const & schema,
std::shared_ptr< IdFactory > const & idFactory )
static

Construct a new table.

Parameters
[in]schemaSchema that defines the fields, offsets, and record size for the table.
[in]idFactoryFactory class to generate record IDs when they are not explicitly given. If null, record IDs will default to zero.

Note that not passing an IdFactory at all will call the other override of make(), which will set the ID factory to IdFactory::makeSimple().

Definition at line 75 of file Simple.cc.

76 {
77 if (!checkSchema(schema)) {
79 "Schema for Simple must contain at least the keys defined by makeMinimalSchema().");
80 }
81 return std::shared_ptr<SimpleTable>(new SimpleTable(schema, idFactory));
82}
#define LSST_EXCEPT(type,...)
Create an exception with a given type.
Definition Exception.h:48
static bool checkSchema(Schema const &other)
Return true if the given schema is a valid SimpleTable schema.
Definition Simple.h:152
Reports invalid arguments.
Definition Runtime.h:66

◆ makeFitsWriter()

std::shared_ptr< io::FitsWriter > lsst::afw::table::SimpleTable::makeFitsWriter ( fits::Fits * fitsfile,
int flags ) const
overrideprivatevirtual

Reimplemented from lsst::afw::table::BaseTable.

Reimplemented in lsst::afw::table::SourceTable.

Definition at line 104 of file Simple.cc.

104 {
105 return std::make_shared<SimpleFitsWriter>(fitsfile, flags);
106}

◆ makeMinimalSchema()

static Schema lsst::afw::table::SimpleTable::makeMinimalSchema ( )
inlinestatic

Return a minimal schema for Simple tables and records.

The returned schema can and generally should be modified further, but many operations on SimpleRecords will assume that at least the fields provided by this routine are present.

Definition at line 140 of file Simple.h.

140 {
141 Schema r = getMinimalSchema().schema;
142 r.disconnectAliases();
143 return r;
144 }

◆ makeRecord()

std::shared_ptr< SimpleRecord > lsst::afw::table::SimpleTable::makeRecord ( )
inline

Default-construct an associated record.

Derived classes should reimplement by static-casting the output of _makeRecord to the appropriate BaseRecord subclass to simulate covariant return types.

Definition at line 179 of file Simple.h.

179 {
180 return std::static_pointer_cast<SimpleRecord>(_makeRecord());
181 }
std::shared_ptr< BaseRecord > _makeRecord() override
Default-construct an associated record (protected implementation).
Definition Simple.cc:112

◆ operator=() [1/2]

SimpleTable & lsst::afw::table::SimpleTable::operator= ( SimpleTable && )
delete

◆ operator=() [2/2]

SimpleTable & lsst::afw::table::SimpleTable::operator= ( SimpleTable const & )
delete

◆ popMetadata()

std::shared_ptr< daf::base::PropertyList > lsst::afw::table::BaseTable::popMetadata ( )
inlineinherited

Return the metadata and set the internal metadata to a null pointer.

Definition at line 85 of file BaseTable.h.

85 {
87 _metadata.swap(tmp);
88 return tmp;
89 }

◆ preallocate()

void lsst::afw::table::BaseTable::preallocate ( std::size_t nRecords)
inherited

Allocate contiguous space for new records in advance.

If a contiguous memory block for at least n additional records has already been allocated, this is a no-op. If not, a new block will be allocated, and any remaining space on the old block will go to waste; this ensures the new records will be allocated contiguously. Note that "wasted" memory is not leaked; it will be deallocated along with any records created from that block when those records go out of scope.

Note that unlike std::vector::reserve, this does not factor in existing records in any way; nRecords refers to a number of new records to reserve space for.

Definition at line 110 of file BaseTable.cc.

110{ Block::preallocate(_schema.getRecordSize(), n, _manager); }

◆ setIdFactory()

void lsst::afw::table::SimpleTable::setIdFactory ( std::shared_ptr< IdFactory > f)
inline

Switch to a new IdFactory – object that generates IDs for the table (may be null).

Definition at line 161 of file Simple.h.

161{ _idFactory = f; }

◆ setMetadata()

void lsst::afw::table::BaseTable::setMetadata ( std::shared_ptr< daf::base::PropertyList > const & metadata)
inlineinherited

Set the flexible metadata associated with the table. May be null.

Definition at line 82 of file BaseTable.h.

82{ _metadata = metadata; }

Friends And Related Symbol Documentation

◆ io::FitsWriter

Definition at line 220 of file Simple.h.

Member Data Documentation

◆ nRecordsPerBlock

int lsst::afw::table::BaseTable::nRecordsPerBlock = 100
staticinherited

Number of records in each memory block.

Definition at line 76 of file BaseTable.h.


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