LSSTApplications  10.0-2-g4f67435,11.0.rc2+1,11.0.rc2+12,11.0.rc2+3,11.0.rc2+4,11.0.rc2+5,11.0.rc2+6,11.0.rc2+7,11.0.rc2+8
LSSTDataManagementBasePackage
Public Types | Public Member Functions | Static Public Member Functions | Static Public Attributes | Protected Member Functions | Private Member Functions | Private Attributes | Friends | List of all members
lsst.afw.table::BaseTable Class Referenceabstract

Base class for all tables. More...

#include <BaseTable.h>

Inheritance diagram for lsst.afw.table::BaseTable:
lsst::daf::base::Citizen lsst.afw.detection::PeakTable lsst.afw.table::AmpInfoTable lsst.afw.table::ExposureTable lsst.afw.table::SimpleTable lsst.afw.table::SourceTable

Public Types

typedef BaseRecord Record
 The associated record class. More...
 
typedef BaseColumnView ColumnView
 The associated ColumnView class. More...
 
typedef CatalogT< RecordCatalog
 Template of CatalogT used to hold records of the associated type. More...
 
typedef CatalogT< Record const > ConstCatalog
 Template of CatalogT used to hold const records of the associated type. More...
 
- Public Types inherited from lsst::daf::base::Citizen
enum  { magicSentinel = 0xdeadbeef }
 
typedef unsigned long memId
 Type of the block's ID. More...
 
typedef memId(* memNewCallback )(const memId cid)
 A function used to register a callback. More...
 
typedef memId(* memCallback )(const Citizen *ptr)
 

Public Member Functions

boost::shared_ptr
< daf::base::PropertyList
getMetadata () const
 Return the flexible metadata associated with the table. May be null. More...
 
void setMetadata (boost::shared_ptr< daf::base::PropertyList > const &metadata)
 Set the flexible metadata associated with the table. May be null. More...
 
boost::shared_ptr
< daf::base::PropertyList
popMetadata ()
 Return the metadata and set the internal metadata to a null pointer. More...
 
boost::shared_ptr< BaseTableclone () const
 Return a polymorphic deep copy of the table. More...
 
boost::shared_ptr< BaseRecordmakeRecord ()
 Default-construct an associated record. More...
 
boost::shared_ptr< BaseRecordcopyRecord (BaseRecord const &input)
 Deep-copy a record, requiring that it have the same schema as this table. More...
 
boost::shared_ptr< BaseRecordcopyRecord (BaseRecord const &input, SchemaMapper const &mapper)
 Deep-copy a record, using a mapper to relate two schemas. More...
 
Schema getSchema () const
 Return the table's schema. More...
 
void preallocate (std::size_t nRecords)
 Allocate contiguous space for new records in advance. More...
 
std::size_t getBufferSize () const
 Return the number of additional records space has been already been allocated for. More...
 
virtual ~BaseTable ()
 
- Public Member Functions inherited from lsst::daf::base::Citizen
 Citizen (const std::type_info &)
 
 Citizen (Citizen const &)
 
 ~Citizen ()
 
Citizenoperator= (Citizen const &)
 
std::string repr () const
 Return a string representation of a Citizen. More...
 
void markPersistent (void)
 Mark a Citizen as persistent and not destroyed until process end. More...
 
memId getId () const
 Return the Citizen's ID. More...
 

Static Public Member Functions

static boost::shared_ptr
< BaseTable
make (Schema const &schema)
 Construct a new table. More...
 
- Static Public Member Functions inherited from lsst::daf::base::Citizen
static bool hasBeenCorrupted ()
 Check all allocated blocks for corruption. More...
 
static memId getNextMemId ()
 Return the memId of the next object to be allocated. More...
 
static int init ()
 Called once when the memory system is being initialised. More...
 
static int census (int, memId startingMemId=0)
 How many active Citizens are there? More...
 
static void census (std::ostream &stream, memId startingMemId=0)
 Print a list of all active Citizens to stream, sorted by ID. More...
 
static const std::vector
< const Citizen * > * 
census ()
 Return a (newly allocated) std::vector of active Citizens sorted by ID. More...
 
static memId setNewCallbackId (memId id)
 Call the NewCallback when block is allocated. More...
 
static memId setDeleteCallbackId (memId id)
 Call the current DeleteCallback when block is deleted. More...
 
static memNewCallback setNewCallback (memNewCallback func)
 Set the NewCallback function. More...
 
static memCallback setDeleteCallback (memCallback func)
 Set the DeleteCallback function. More...
 
static memCallback setCorruptionCallback (memCallback func)
 Set the CorruptionCallback function. More...
 

Static Public Attributes

static int nRecordsPerBlock
 Number of records in each memory block. More...
 

Protected Member Functions

template<typename Derived >
boost::shared_ptr< Derived > getSelf ()
 Convenience function for static-casting shared_from_this for use by derived classes. More...
 
template<typename Derived >
boost::shared_ptr< Derived const > getSelf () const
 Convenience function for static-casting shared_from_this for use by derived classes. More...
 
virtual void handleAliasChange (std::string const &alias)
 
virtual boost::shared_ptr
< BaseTable
_clone () const =0
 Clone implementation with noncovariant return types. More...
 
virtual boost::shared_ptr
< BaseRecord
_makeRecord ()=0
 Default-construct an associated record (protected implementation). More...
 
 BaseTable (Schema const &schema)
 Construct from a schema. More...
 
 BaseTable (BaseTable const &other)
 Copy construct. More...
 

Private Member Functions

void _initialize (BaseRecord &record)
 
void _destroy (BaseRecord &record)
 
void operator= (BaseTable const &other)
 
virtual boost::shared_ptr
< io::FitsWriter
makeFitsWriter (fits::Fits *fitsfile, int flags) const
 

Private Attributes

Schema _schema
 
ndarray::Manager::Ptr _manager
 
boost::shared_ptr
< daf::base::PropertyList
_metadata
 

Friends

class BaseRecord
 
class io::FitsWriter
 
class AliasMap
 

Detailed Description

Base class for all tables.

Tables have two largely distinct purposes:

It's mostly a matter of convenience that we use the same class to serve both needs.

Tables do not actually maintain a list of all the records they have allocated - but those records hold a pointer back to the table. This allows the work of holding and iterating over records to be delegated to templated container classes (such as CatalogT) while allowing tables to be polymorphic, non-template classes. In some sense, then, it may make more sense to think of a table as a combination factory and "container header".

Tables are always created in shared_ptrs (a requirement of enable_shared_from_this). BaseTable provides a make static member function to create a new table, and most derived table classes should do the same.

Each table class should be associated with a particular record class (1-to-1). Each table instance may be associated with many record instances.

Definition at line 44 of file BaseTable.h.

Member Typedef Documentation

Template of CatalogT used to hold records of the associated type.

Definition at line 59 of file BaseTable.h.

The associated ColumnView class.

Definition at line 56 of file BaseTable.h.

Template of CatalogT used to hold const records of the associated type.

Definition at line 62 of file BaseTable.h.

The associated record class.

Definition at line 53 of file BaseTable.h.

Constructor & Destructor Documentation

virtual lsst.afw.table::BaseTable::~BaseTable ( )
virtual
lsst.afw.table::BaseTable::BaseTable ( Schema const &  schema)
explicitprotected

Construct from a schema.

lsst.afw.table::BaseTable::BaseTable ( BaseTable const &  other)
inlineprotected

Copy construct.

Definition at line 191 of file BaseTable.h.

191  :
192  daf::base::Citizen(other), _schema(other._schema),
193  _metadata(other._metadata)
194  {
195  if (_metadata)
196  _metadata = boost::static_pointer_cast<daf::base::PropertyList>(_metadata->deepCopy());
197  }
lsst::daf::base::PropertyList PropertyList
Definition: Wcs.cc:59
boost::shared_ptr< daf::base::PropertyList > _metadata
Definition: BaseTable.h:230

Member Function Documentation

virtual boost::shared_ptr< BaseTable > lsst.afw.table::BaseTable::_clone ( ) const
protectedpure virtual

Clone implementation with noncovariant return types.

void lsst.afw.table::BaseTable::_destroy ( BaseRecord record)
private
void lsst.afw.table::BaseTable::_initialize ( BaseRecord record)
private
virtual boost::shared_ptr< BaseRecord > lsst.afw.table::BaseTable::_makeRecord ( )
protectedpure virtual

Default-construct an associated record (protected implementation).

boost::shared_ptr< BaseTable > lsst.afw.table::BaseTable::clone ( void  ) 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 89 of file BaseTable.h.

89 { return _clone(); }
virtual boost::shared_ptr< BaseTable > _clone() const =0
Clone implementation with noncovariant return types.
boost::shared_ptr< BaseRecord > lsst.afw.table::BaseTable::copyRecord ( BaseRecord const &  input)

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.

boost::shared_ptr< BaseRecord > lsst.afw.table::BaseTable::copyRecord ( BaseRecord const &  input,
SchemaMapper const &  mapper 
)

Deep-copy a record, using a mapper to relate two schemas.

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.

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

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.

boost::shared_ptr< daf::base::PropertyList > lsst.afw.table::BaseTable::getMetadata ( ) const
inline

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

Definition at line 68 of file BaseTable.h.

68 { return _metadata; }
boost::shared_ptr< daf::base::PropertyList > _metadata
Definition: BaseTable.h:230
Schema lsst.afw.table::BaseTable::getSchema ( ) const
inline

Return the table's schema.

Definition at line 126 of file BaseTable.h.

126 { return _schema; }
template<typename Derived >
boost::shared_ptr< Derived > lsst.afw.table::BaseTable::getSelf ( )
inlineprotected

Convenience function for static-casting shared_from_this for use by derived classes.

Definition at line 169 of file BaseTable.h.

169  {
170  return boost::static_pointer_cast<Derived>(shared_from_this());
171  }
template<typename Derived >
boost::shared_ptr< Derived const> lsst.afw.table::BaseTable::getSelf ( ) const
inlineprotected

Convenience function for static-casting shared_from_this for use by derived classes.

Definition at line 175 of file BaseTable.h.

175  {
176  return boost::static_pointer_cast<Derived const>(shared_from_this());
177  }
virtual void lsst.afw.table::BaseTable::handleAliasChange ( std::string const &  alias)
inlineprotectedvirtual

Reimplemented in lsst.afw.table::SourceTable.

Definition at line 179 of file BaseTable.h.

179 {}
static boost::shared_ptr< BaseTable > lsst.afw.table::BaseTable::make ( Schema const &  schema)
static

Construct a new table.

Because BaseTable is an abstract class, this actually returns a hidden trivial subclass (which is associated with a hidden trivial subclass of BaseRecord).

Hiding concrete table and record classes in anonymous namespaces is not required, but it makes it easier to ensure instances are always created within shared_ptrs, and it eliminates some multilateral friending that would otherwise be necessary. In some cases it may also serve as a form of pimpl, keeping class implementation details out of header files.

virtual boost::shared_ptr< io::FitsWriter > lsst.afw.table::BaseTable::makeFitsWriter ( fits::Fits fitsfile,
int  flags 
) const
privatevirtual
boost::shared_ptr< BaseRecord > lsst.afw.table::BaseTable::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 97 of file BaseTable.h.

97 { return _makeRecord(); }
virtual boost::shared_ptr< BaseRecord > _makeRecord()=0
Default-construct an associated record (protected implementation).
void lsst.afw.table::BaseTable::operator= ( BaseTable const &  other)
private
boost::shared_ptr< daf::base::PropertyList > lsst.afw.table::BaseTable::popMetadata ( )
inline

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

Definition at line 74 of file BaseTable.h.

74  {
76  _metadata.swap(tmp);
77  return tmp;
78  }
#define PTR(...)
Definition: base.h:41
void swap(ImageBase< PixelT > &a, ImageBase< PixelT > &b)
Definition: Image.cc:291
lsst::daf::base::PropertyList PropertyList
Definition: Wcs.cc:59
boost::shared_ptr< daf::base::PropertyList > _metadata
Definition: BaseTable.h:230
void lsst.afw.table::BaseTable::preallocate ( std::size_t  nRecords)

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.

void lsst.afw.table::BaseTable::setMetadata ( boost::shared_ptr< daf::base::PropertyList > const &  metadata)
inline

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

Definition at line 71 of file BaseTable.h.

71 { _metadata = metadata; }
boost::shared_ptr< daf::base::PropertyList > _metadata
Definition: BaseTable.h:230

Friends And Related Function Documentation

friend class AliasMap
friend

Definition at line 203 of file BaseTable.h.

friend class BaseRecord
friend

Definition at line 201 of file BaseTable.h.

friend class io::FitsWriter
friend

Definition at line 202 of file BaseTable.h.

Member Data Documentation

ndarray::Manager::Ptr lsst.afw.table::BaseTable::_manager
private

Definition at line 229 of file BaseTable.h.

boost::shared_ptr< daf::base::PropertyList > lsst.afw.table::BaseTable::_metadata
private

Definition at line 230 of file BaseTable.h.

Schema lsst.afw.table::BaseTable::_schema
private

Definition at line 228 of file BaseTable.h.

int lsst.afw.table::BaseTable::nRecordsPerBlock
static

Number of records in each memory block.

Definition at line 65 of file BaseTable.h.


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