lsst::afw::table::ExposureCatalogT< RecordT > Class Template Reference

Custom catalog class for ExposureRecord/Table. More...

#include <Exposure.h>

Inheritance diagram for lsst::afw::table::ExposureCatalogT< RecordT >:

Public Types
typedef RecordT	Record
typedef Record::Table	Table
typedef Base::iterator	iterator
typedef Base::const_iterator	const_iterator
typedef Record::ColumnView	ColumnView
typedef RecordT	value_type
typedef RecordT &	reference
typedef std::shared_ptr< RecordT >	pointer
typedef Internal::size_type	size_type
typedef Internal::difference_type	difference_type

Public Member Functions
	ExposureCatalogT (std::shared_ptr< Table > const &table=std::shared_ptr< Table >())
	Construct a vector from a table (or nothing). More...
	ExposureCatalogT (Schema const &schema)
	Construct a vector from a schema, creating a table with Table::make(schema). More...
template<typename InputIterator >
	ExposureCatalogT (std::shared_ptr< Table > const &table, InputIterator first, InputIterator last, bool deep=false)
	Construct a vector from a table and an iterator range. More...
template<typename OtherRecordT >
	ExposureCatalogT (ExposureCatalogT< OtherRecordT > const &other)
	Shallow copy constructor from a container containing a related record type. More...
	ExposureCatalogT (ExposureCatalogT const &)=default
	ExposureCatalogT (ExposureCatalogT &&)=default
ExposureCatalogT &	operator= (ExposureCatalogT const &)=default
ExposureCatalogT &	operator= (ExposureCatalogT &&)=default
	~ExposureCatalogT ()=default
void	writeFits (fits::Fits &fitsfile, std::shared_ptr< io::OutputArchive > archive, int flags=0) const
	Write a FITS binary table to an open file object. More...
void	writeToArchive (io::OutputArchiveHandle &handle, bool ignoreUnpersistable=true) const
	Convenience output function for Persistables that contain an ExposureCatalog. More...
ExposureCatalogT< RecordT >	subset (ndarray::Array< bool const, 1 > const &mask) const
	Return the subset of a catalog corresponding to the True values of the given mask array. More...
ExposureCatalogT	subset (std::ptrdiff_t startd, std::ptrdiff_t stopd, std::ptrdiff_t step) const
	Shallow copy a subset of another ExposureCatalog. More...
ExposureCatalogT	subsetContaining (lsst::geom::SpherePoint const &coord, bool includeValidPolygon=false) const
	Return a shallow subset of the catalog with only those records that contain the given point. More...
ExposureCatalogT	subsetContaining (lsst::geom::Point2D const &point, geom::SkyWcs const &wcs, bool includeValidPolygon=false) const
	Return a shallow subset of the catalog with only those records that contain the given point. More...
bool	isSorted () const
	Return true if the vector is in ascending ID order. More...
template<typename T >
bool	isSorted (Key< T > const &key) const
	Return true if the catalog is in ascending order according to the given key. More...
template<typename Compare >
bool	isSorted (Compare cmp) const
	Return true if the catalog is in ascending order according to the given predicate. More...
void	sort ()
	Sort the vector in-place by ID. More...
template<typename T >
void	sort (Key< T > const &key)
	Sort the catalog in-place by the field with the given key. More...
template<typename Compare >
void	sort (Compare cmp)
	Sort the catalog in-place by the field with the given predicate. More...
std::shared_ptr< Table >	getTable () const
	Return the table associated with the catalog. More...
Schema	getSchema () const
	Return the schema associated with the catalog's table. More...
void	writeFits (std::string const &filename, std::string const &mode="w", int flags=0) const
	Write a FITS binary table to a regular file. More...
void	writeFits (fits::MemFileManager &manager, std::string const &mode="w", int flags=0) const
	Write a FITS binary table to a RAM file. More...
void	writeFits (fits::Fits &fitsfile, int flags=0) const
	Write a FITS binary table to an open file object. More...
ColumnView	getColumnView () const
	Return a ColumnView of this catalog's records. More...
bool	isContiguous () const
	Return true if all records are contiguous. More...
bool	empty () const
	Return true if the catalog has no records. More...
size_type	size () const
	Return the number of elements in the catalog. More...
size_type	max_size () const
	Return the maximum number of elements allowed in a catalog. More...
size_type	capacity () const
	Return the capacity of the catalog. More...
void	reserve (size_type n)
	Increase the capacity of the catalog to the given size. More...
void	resize (size_type n)
	Change the size of the catalog, removing or adding empty records as needed. More...
reference	operator[] (size_type i) const
	Return the record at index i. More...
reference	at (size_type i) const
	Return the record at index i (throws std::out_of_range). More...
reference	front () const
	Return the first record. More...
reference	back () const
	Return the last record. More...
std::shared_ptr< RecordT > const	get (size_type i) const
	Return a pointer to the record at index i. More...
void	set (size_type i, std::shared_ptr< RecordT > const &p)
	Set the record at index i to a pointer. More...
template<typename InputIterator >
void	assign (InputIterator first, InputIterator last, bool deep=false)
	Replace the contents of the table with an iterator range. More...
void	push_back (Record const &r)
	Add a copy of the given record to the end of the catalog. More...
void	push_back (std::shared_ptr< RecordT > const &p)
	Add the given record to the end of the catalog without copying. More...
std::shared_ptr< RecordT >	addNew ()
	Create a new record, add it to the end of the catalog, and return a pointer to it. More...
void	pop_back ()
	Remove the last record in the catalog. More...
CatalogT	copy () const
	Deep-copy the catalog using a cloned table. More...
template<typename InputIterator >
void	insert (iterator pos, InputIterator first, InputIterator last, bool deep=false)
	Insert an iterator range into the table. More...
template<typename InputIterator >
void	insert (SchemaMapper const &mapper, iterator pos, InputIterator first, InputIterator last)
	Insert a range of records into the catalog by copying them with a SchemaMapper. More...
iterator	insert (iterator pos, Record const &r)
	Insert a copy of the given record at the given position. More...
iterator	insert (iterator pos, std::shared_ptr< RecordT > const &p)
	Insert the given record at the given position without copying. More...
iterator	erase (iterator pos)
	Erase the record pointed to by pos, and return an iterator the next record. More...
iterator	erase (iterator first, iterator last)
	Erase the records in the range [first, last). More...
void	swap (CatalogT &other) noexcept
	Shallow swap of two catalogs. More...
void	clear ()
	Remove all records from the catalog. More...
template<typename T >
std::pair< typename CatalogT< RecordT >::iterator, typename CatalogT< RecordT >::iterator >	equal_range (typename Field< T >::Value const &value, Key< T > const &key)
template<typename T >
std::pair< typename CatalogT< RecordT >::const_iterator, typename CatalogT< RecordT >::const_iterator >	equal_range (typename Field< T >::Value const &value, Key< T > const &key) const
iterator	find (RecordId id)
	Return an iterator to the record with the given ID. More...
const_iterator	find (RecordId id) const
	Return an iterator to the record with the given ID. More...
template<typename T >
iterator	find (typename Field< T >::Value const &value, Key< T > const &key)
	Return an iterator to the record with the given value. More...
template<typename T >
const_iterator	find (typename Field< T >::Value const &value, Key< T > const &key) const
	Return an iterator to the record with the given value. More...
iterator	begin ()
	Iterator access. More...
const_iterator	begin () const
	Iterator access. More...
iterator	end ()
	Iterator access. More...
const_iterator	end () const
	Iterator access. More...
const_iterator	cbegin () const
	Iterator access. More...
const_iterator	cend () const
	Iterator access. More...
template<typename T >
iterator	lower_bound (typename Field< T >::Value const &value, Key< T > const &key)
	Performed binary searches on sorted fields. More...
template<typename T >
const_iterator	lower_bound (typename Field< T >::Value const &value, Key< T > const &key) const
	Performed binary searches on sorted fields. More...
template<typename T >
iterator	upper_bound (typename Field< T >::Value const &value, Key< T > const &key)
	Performed binary searches on sorted fields. More...
template<typename T >
const_iterator	upper_bound (typename Field< T >::Value const &value, Key< T > const &key) const
	Performed binary searches on sorted fields. More...
template<typename T >
std::pair< iterator, iterator >	equal_range (typename Field< T >::Value const &value, Key< T > const &key)
	Performed binary searches on sorted fields. More...
template<typename T >
std::pair< const_iterator, const_iterator >	equal_range (typename Field< T >::Value const &value, Key< T > const &key) const
	Performed binary searches on sorted fields. More...
Internal &	getInternal ()
	Return a reference to the internal vector-of-shared_ptr. More...
Internal const &	getInternal () const
	Return a reference to the internal vector-of-shared_ptr. More...

Static Public Member Functions
static ExposureCatalogT	readFits (std::string const &filename, int hdu=fits::DEFAULT_HDU, int flags=0)
	Read a FITS binary table from a regular file. More...
static ExposureCatalogT	readFits (fits::MemFileManager &manager, int hdu=fits::DEFAULT_HDU, int flags=0)
	Read a FITS binary table from a RAM file. More...
static ExposureCatalogT	readFits (fits::Fits &fitsfile, int flags=0)
	Read a FITS binary table from a file object already at the correct extension. More...
static ExposureCatalogT	readFits (fits::Fits &fitsfile, std::shared_ptr< io::InputArchive > archive, int flags=0)
	Read a FITS binary table from a file object already at the correct extension. More...
static ExposureCatalogT	readFromArchive (io::InputArchive const &archive, BaseCatalog const &catalog)
	Convenience input function for Persistables that contain an ExposureCatalog. More...

Protected Member Functions
	ExposureCatalogT (Base const &other)

Detailed Description

template<typename RecordT>
class lsst::afw::table::ExposureCatalogT< RecordT >

Custom catalog class for ExposureRecord/Table.

We don't expect to subclass ExposureRecord/Table, so unlike other Catalogs we can (and do) define some ExposureCatalogT member functions in Exposure.cc where the explicit instantiation is done.

Definition at line 67 of file Exposure.h.

Member Typedef Documentation

ColumnView

template<typename RecordT>

typedef Record::ColumnView lsst::afw::table::CatalogT< RecordT >::ColumnView

inherited

Definition at line 103 of file Catalog.h.

const_iterator

template<typename RecordT>

typedef Base::const_iterator lsst::afw::table::ExposureCatalogT< RecordT >::const_iterator

Definition at line 319 of file Exposure.h.

difference_type

template<typename RecordT>

typedef Internal::difference_type lsst::afw::table::CatalogT< RecordT >::difference_type

inherited

Definition at line 109 of file Catalog.h.

iterator

template<typename RecordT>

typedef Base::iterator lsst::afw::table::ExposureCatalogT< RecordT >::iterator

Definition at line 318 of file Exposure.h.

pointer

template<typename RecordT>

typedef std::shared_ptr<RecordT> lsst::afw::table::CatalogT< RecordT >::pointer

inherited

Definition at line 107 of file Catalog.h.

Record

template<typename RecordT>

typedef RecordT lsst::afw::table::ExposureCatalogT< RecordT >::Record

Definition at line 315 of file Exposure.h.

reference

template<typename RecordT>

typedef RecordT& lsst::afw::table::CatalogT< RecordT >::reference

inherited

Definition at line 106 of file Catalog.h.

size_type

template<typename RecordT>

typedef Internal::size_type lsst::afw::table::CatalogT< RecordT >::size_type

inherited

Definition at line 108 of file Catalog.h.

Table

template<typename RecordT>

typedef Record::Table lsst::afw::table::ExposureCatalogT< RecordT >::Table

Definition at line 316 of file Exposure.h.

value_type

template<typename RecordT>

typedef RecordT lsst::afw::table::CatalogT< RecordT >::value_type

inherited

Definition at line 105 of file Catalog.h.

Constructor & Destructor Documentation

ExposureCatalogT() [1/7]

template<typename RecordT>

lsst::afw::table::ExposureCatalogT< RecordT >::ExposureCatalogT ( std::shared_ptr< Table > const &  table = std::shared_ptr<Table>() )

inlineexplicit

Construct a vector from a table (or nothing).

A vector with no table is considered invalid; a valid table must be assigned to it before it can be used.

Definition at line 327 of file Exposure.h.

: Base(table) {}

ExposureCatalogT() [2/7]

template<typename RecordT>

lsst::afw::table::ExposureCatalogT< RecordT >::ExposureCatalogT ( Schema const &  schema )

inlineexplicit

Construct a vector from a schema, creating a table with Table::make(schema).

Definition at line 330 of file Exposure.h.

: Base(schema) {}

ExposureCatalogT() [3/7]

template<typename RecordT>

template<typename InputIterator >

lsst::afw::table::ExposureCatalogT< RecordT >::ExposureCatalogT ( std::shared_ptr< Table > const &  table, InputIterator  first, InputIterator  last, bool  deep = false  )

inline

Construct a vector from a table and an iterator range.

If deep is true, new records will be created using table->copyRecord before being inserted. If deep is false, records will be not be copied, but they must already be associated with the given table. The table itself is never deep-copied.

The iterator must dereference to a record reference or const reference rather than a pointer, but should be implicitly convertible to a record pointer as well (see CatalogIterator).

Definition at line 343 of file Exposure.h.

            : Base(table, first, last, deep) {}

ExposureCatalogT() [4/7]

template<typename RecordT>

template<typename OtherRecordT >

lsst::afw::table::ExposureCatalogT< RecordT >::ExposureCatalogT ( ExposureCatalogT< OtherRecordT > const &  other )

inline

Shallow copy constructor from a container containing a related record type.

This conversion only succeeds if OtherRecordT is convertible to RecordT and OtherTable is convertible to Table.

Definition at line 354 of file Exposure.h.

: Base(other) {}

ExposureCatalogT() [5/7]

template<typename RecordT>

lsst::afw::table::ExposureCatalogT< RecordT >::ExposureCatalogT ( ExposureCatalogT< RecordT > const &  )

default

ExposureCatalogT() [6/7]

template<typename RecordT>

lsst::afw::table::ExposureCatalogT< RecordT >::ExposureCatalogT ( ExposureCatalogT< RecordT > &&  )

default

~ExposureCatalogT()

template<typename RecordT>

lsst::afw::table::ExposureCatalogT< RecordT >::~ExposureCatalogT ( )

default

ExposureCatalogT() [7/7]

template<typename RecordT>

lsst::afw::table::ExposureCatalogT< RecordT >::ExposureCatalogT ( Base const &  other )

inlineexplicitprotected

Definition at line 485 of file Exposure.h.

: Base(other) {}

Member Function Documentation

addNew()

template<typename RecordT>

std::shared_ptr<RecordT> lsst::afw::table::CatalogT< RecordT >::addNew ( )

inlineinherited

Create a new record, add it to the end of the catalog, and return a pointer to it.

Definition at line 485 of file Catalog.h.

                                    {
        std::shared_ptr<RecordT> r = _table->makeRecord();
        _internal.push_back(r);
        return r;
    }

assign()

template<typename RecordT>

template<typename InputIterator >

void lsst::afw::table::CatalogT< RecordT >::assign ( InputIterator  first, InputIterator  last, bool  deep = false  )

inlineinherited

Replace the contents of the table with an iterator range.

Delegates to insert(); look there for more information.

Definition at line 470 of file Catalog.h.

                                                                            {
        clear();
        insert(end(), first, last, deep);
    }

at()

template<typename RecordT>

reference lsst::afw::table::CatalogT< RecordT >::at ( size_type  i ) const

inlineinherited

Return the record at index i (throws std::out_of_range).

Definition at line 450 of file Catalog.h.

{ return *_internal.at(i); }

back()

template<typename RecordT>

reference lsst::afw::table::CatalogT< RecordT >::back ( ) const

inlineinherited

Return the last record.

Definition at line 456 of file Catalog.h.

{ return *_internal.back(); }

begin() [1/2]

template<typename RecordT>

iterator lsst::afw::table::CatalogT< RecordT >::begin ( )

inlineinherited

Iterator access.

See also

CatalogIterator

Definition at line 396 of file Catalog.h.

{ return iterator(_internal.begin()); }

begin() [2/2]

template<typename RecordT>

const_iterator lsst::afw::table::CatalogT< RecordT >::begin ( ) const

inlineinherited

Iterator access.

See also

CatalogIterator

Definition at line 398 of file Catalog.h.

{ return const_iterator(_internal.begin()); }

capacity()

template<typename RecordT>

size_type lsst::afw::table::CatalogT< RecordT >::capacity ( ) const

inlineinherited

Return the capacity of the catalog.

This is computed as the sum of the current size and the unallocated space in the table. It does not reflect the size of the internal vector, and hence cannot be used to judge when iterators may be invalidated.

Definition at line 420 of file Catalog.h.

{ return _internal.size() + _table->getBufferSize(); }

cbegin()

template<typename RecordT>

const_iterator lsst::afw::table::CatalogT< RecordT >::cbegin ( ) const

inlineinherited

Iterator access.

See also

CatalogIterator

Definition at line 400 of file Catalog.h.

{ return begin(); }

cend()

template<typename RecordT>

const_iterator lsst::afw::table::CatalogT< RecordT >::cend ( ) const

inlineinherited

Iterator access.

See also

CatalogIterator

Definition at line 401 of file Catalog.h.

{ return end(); }

clear()

template<typename RecordT>

void lsst::afw::table::CatalogT< RecordT >::clear ( )

inlineinherited

Remove all records from the catalog.

Definition at line 574 of file Catalog.h.

{ _internal.clear(); }

copy()

template<typename RecordT>

CatalogT lsst::afw::table::CatalogT< RecordT >::copy ( ) const

inlineinherited

Deep-copy the catalog using a cloned table.

Definition at line 495 of file Catalog.h.

{ return CatalogT(getTable()->clone(), begin(), end(), true); }

empty()

template<typename RecordT>

bool lsst::afw::table::CatalogT< RecordT >::empty ( ) const

inlineinherited

Return true if the catalog has no records.

Definition at line 405 of file Catalog.h.

{ return _internal.empty(); }

end() [1/2]

template<typename RecordT>

iterator lsst::afw::table::CatalogT< RecordT >::end ( )

inlineinherited

Iterator access.

See also

CatalogIterator

Definition at line 397 of file Catalog.h.

{ return iterator(_internal.end()); }

end() [2/2]

template<typename RecordT>

const_iterator lsst::afw::table::CatalogT< RecordT >::end ( ) const

inlineinherited

Iterator access.

See also

CatalogIterator

Definition at line 399 of file Catalog.h.

{ return const_iterator(_internal.end()); }

equal_range() [1/4]

template<typename RecordT>

template<typename T >

std::pair<iterator, iterator> lsst::afw::table::CatalogT< RecordT >::equal_range ( typename Field< T >::Value const &  value, Key< T > const &  key  )

inherited

Performed binary searches on sorted fields.

These methods perform binary searches analogous to the STL algorithms of the same name; they simply create a comparison functor using the given value and Key.

In Python, the lower_bound and upper_bound methods return the position of the result record in the catalog, and equal_range returns a Python slice object that defines the range.

Note

The catalog must be sorted in ascending order according to the given key before calling any of the search methods (i.e. isSorted(key) must be true).

equal_range() [2/4]

template<typename RecordT>

template<typename T >

std::pair<const_iterator, const_iterator> lsst::afw::table::CatalogT< RecordT >::equal_range ( typename Field< T >::Value const &  value, Key< T > const &  key  ) const

inherited

Performed binary searches on sorted fields.

These methods perform binary searches analogous to the STL algorithms of the same name; they simply create a comparison functor using the given value and Key.

In Python, the lower_bound and upper_bound methods return the position of the result record in the catalog, and equal_range returns a Python slice object that defines the range.

Note

The catalog must be sorted in ascending order according to the given key before calling any of the search methods (i.e. isSorted(key) must be true).

equal_range() [3/4]

template<typename RecordT>

template<typename T >

std::pair<typename CatalogT<RecordT>::iterator, typename CatalogT<RecordT>::iterator> lsst::afw::table::CatalogT< RecordT >::equal_range ( typename Field< T >::Value const &  value, Key< T > const &  key  )

inherited

Definition at line 827 of file Catalog.h.

                                                                                     {
    detail::KeyExtractionFunctor<RecordT, T> f = {key};
    // Iterator adaptor that makes a CatalogT iterator work like an iterator over field values.
    typedef boost::transform_iterator<detail::KeyExtractionFunctor<RecordT, T>, iterator> SearchIter;
    std::pair<SearchIter, SearchIter> i =
            std::equal_range(SearchIter(begin(), f), SearchIter(end(), f), value);
    return std::make_pair(i.first.base(), i.second.base());
}

equal_range() [4/4]

template<typename RecordT>

template<typename T >

std::pair<typename CatalogT<RecordT>::const_iterator, typename CatalogT<RecordT>::const_iterator> lsst::afw::table::CatalogT< RecordT >::equal_range ( typename Field< T >::Value const &  value, Key< T > const &  key  ) const

inherited

Definition at line 839 of file Catalog.h.

                                                                                           {
    detail::KeyExtractionFunctor<RecordT, T> f = {key};
    // Iterator adaptor that makes a CatalogT iterator work like an iterator over field values.
    typedef boost::transform_iterator<detail::KeyExtractionFunctor<RecordT, T>, const_iterator> SearchIter;
    std::pair<SearchIter, SearchIter> i =
            std::equal_range(SearchIter(begin(), f), SearchIter(end(), f), value);
    return std::make_pair(i.first.base(), i.second.base());
}

erase() [1/2]

template<typename RecordT>

iterator lsst::afw::table::CatalogT< RecordT >::erase ( iterator  pos )

inlineinherited

Erase the record pointed to by pos, and return an iterator the next record.

Definition at line 560 of file Catalog.h.

{ return iterator(_internal.erase(pos.base())); }

erase() [2/2]

template<typename RecordT>

iterator lsst::afw::table::CatalogT< RecordT >::erase ( iterator  first, iterator  last  )

inlineinherited

Erase the records in the range [first, last).

Definition at line 563 of file Catalog.h.

                                                  {
        return iterator(_internal.erase(first.base(), last.base()));
    }

find() [1/4]

template<typename RecordT>

iterator lsst::afw::table::SortedCatalogT< RecordT >::find ( RecordId  id )

inlineinherited

Return an iterator to the record with the given ID.

Note

The vector must be sorted in ascending ID order before calling find (i.e. isSorted() must be true).

Returns end() if the Record cannot be found.

Definition at line 77 of file SortedCatalog.h.

{ return this->find(id, Table::getIdKey()); }

find() [2/4]

template<typename RecordT>

const_iterator lsst::afw::table::SortedCatalogT< RecordT >::find ( RecordId  id ) const

inlineinherited

Return an iterator to the record with the given ID.

Note

The vector must be sorted in ascending ID order before calling find (i.e. isSorted() must be true).

Returns end() if the Record cannot be found.

Definition at line 78 of file SortedCatalog.h.

{ return this->find(id, Table::getIdKey()); }

find() [3/4]

template<typename RecordT >

template<typename T >

CatalogT< RecordT >::iterator lsst::afw::table::CatalogT< RecordT >::find ( typename Field< T >::Value const &  value, Key< T > const &  key  )

inherited

Return an iterator to the record with the given value.

When the field being searched is not unique, which matching record will be returned is not defined. In these cases, lower_bound, upper_bound, or equal_range should be used instead.

In Python, this method returns a Record, not an iterator.

Note

The catalog must be sorted in ascending order according to the given key before calling find (i.e. isSorted(key) must be true).

Returns end() if the Record cannot be found.

Definition at line 756 of file Catalog.h.

                                                                                {
    detail::KeyExtractionFunctor<RecordT, T> f = {key};
    // Iterator adaptor that makes a CatalogT iterator work like an iterator over field values.
    typedef boost::transform_iterator<detail::KeyExtractionFunctor<RecordT, T>, iterator> SearchIter;
    // Use binary search for log n search; requires sorted table.
    SearchIter i = std::lower_bound(SearchIter(begin(), f), SearchIter(end(), f), value);
    if (i.base() == end() || *i != value) return end();
    return i.base();
}

find() [4/4]

template<typename RecordT >

template<typename T >

CatalogT< RecordT >::const_iterator lsst::afw::table::CatalogT< RecordT >::find ( typename Field< T >::Value const &  value, Key< T > const &  key  ) const

inherited

Return an iterator to the record with the given value.

When the field being searched is not unique, which matching record will be returned is not defined. In these cases, lower_bound, upper_bound, or equal_range should be used instead.

In Python, this method returns a Record, not an iterator.

Note

The catalog must be sorted in ascending order according to the given key before calling find (i.e. isSorted(key) must be true).

Returns end() if the Record cannot be found.

Definition at line 769 of file Catalog.h.

                                                                                            {
    detail::KeyExtractionFunctor<RecordT, T> f = {key};
    // Iterator adaptor that makes a CatalogT iterator work like an iterator over field values.
    typedef boost::transform_iterator<detail::KeyExtractionFunctor<RecordT, T>, const_iterator> SearchIter;
    // Use binary search for log n search; requires sorted table.
    SearchIter i = std::lower_bound(SearchIter(begin(), f), SearchIter(end(), f), value);
    if (i.base() == end() || *i != value) return end();
    return i.base();
}

front()

template<typename RecordT>

reference lsst::afw::table::CatalogT< RecordT >::front ( ) const

inlineinherited

Return the first record.

Definition at line 453 of file Catalog.h.

{ return *_internal.front(); }

get()

template<typename RecordT>

std::shared_ptr<RecordT> const lsst::afw::table::CatalogT< RecordT >::get ( size_type  i ) const

inlineinherited

Return a pointer to the record at index i.

Definition at line 459 of file Catalog.h.

{ return _internal[i]; }

getColumnView()

template<typename RecordT>

ColumnView lsst::afw::table::CatalogT< RecordT >::getColumnView ( ) const

inlineinherited

Return a ColumnView of this catalog's records.

Will throw RuntimeError if records are not contiguous.

Definition at line 377 of file Catalog.h.

                                     {
        if (std::is_const<RecordT>::value) {
            throw LSST_EXCEPT(
                    pex::exceptions::LogicError,
                    "Cannot get a column view from a CatalogT<RecordT const> (as column views are always "
                    "non-const views).");
        }
        return ColumnView::make(_table, begin(), end());
    }

getInternal() [1/2]

template<typename RecordT>

Internal& lsst::afw::table::CatalogT< RecordT >::getInternal ( )

inlineinherited

Return a reference to the internal vector-of-shared_ptr.

While in most cases it is more convenient to use the Catalog's iterators, which dereference directly to Record objects (and hence allow iter->method() rather than (**iter).method()), direct access to the underlying vector-of-shared_ptr is provided here to allow complete use of the C++ STL. In particular, in order to use a mutating STL algorithm on a Catalog in such a way that Records are shallow-copied (i.e. shared_ptr::operator= is invoked instead of Record::operator=), those algorithms should be called on the iterators of these internal containers. When an algorithm should be called in such a way that records are deep-copied, the regular Catalog iterators should be used.

Definition at line 669 of file Catalog.h.

{ return _internal; }

getInternal() [2/2]

template<typename RecordT>

Internal const& lsst::afw::table::CatalogT< RecordT >::getInternal ( ) const

inlineinherited

Return a reference to the internal vector-of-shared_ptr.

While in most cases it is more convenient to use the Catalog's iterators, which dereference directly to Record objects (and hence allow iter->method() rather than (**iter).method()), direct access to the underlying vector-of-shared_ptr is provided here to allow complete use of the C++ STL. In particular, in order to use a mutating STL algorithm on a Catalog in such a way that Records are shallow-copied (i.e. shared_ptr::operator= is invoked instead of Record::operator=), those algorithms should be called on the iterators of these internal containers. When an algorithm should be called in such a way that records are deep-copied, the regular Catalog iterators should be used.

Definition at line 670 of file Catalog.h.

{ return _internal; }

getSchema()

template<typename RecordT>

Schema lsst::afw::table::CatalogT< RecordT >::getSchema ( ) const

inlineinherited

Return the schema associated with the catalog's table.

Definition at line 117 of file Catalog.h.

{ return _table->getSchema(); }

getTable()

template<typename RecordT>

std::shared_ptr<Table> lsst::afw::table::CatalogT< RecordT >::getTable ( ) const

inlineinherited

Return the table associated with the catalog.

Definition at line 114 of file Catalog.h.

{ return _table; }

insert() [1/4]

template<typename RecordT>

template<typename InputIterator >

void lsst::afw::table::CatalogT< RecordT >::insert ( iterator  pos, InputIterator  first, InputIterator  last, bool  deep = false  )

inlineinherited

Insert an iterator range into the table.

InputIterator must dereference to a record reference that is convertible to the record type held by the catalog, and must be implicitly convertible to a shared_ptr to a record.

If deep is true, new records will be created by calling copyRecord on the catalog's table. If deep is false, the new records will not be copied, but they must have been created with the catalog's table (note that a table may be shared by multiple catalogs).

If InputIterator models RandomAccessIterator (according to std::iterator_traits) and deep is true, table->preallocate will be used to ensure that the resulting records are contiguous in memory and can be used with ColumnView. To ensure this is the case for other iterator types, the user must preallocate the table manually.

Definition at line 513 of file Catalog.h.

                                                                                          {
        _maybeReserve(pos, first, last, deep,
                      (typename std::iterator_traits<InputIterator>::iterator_category*)0);
        if (deep) {
            while (first != last) {
                pos = insert(pos, *first);
                ++pos;
                ++first;
            }
        } else {
            while (first != last) {
                pos = insert(pos, first);
                assert(pos != end());
                ++pos;
                ++first;
            }
        }
    }

insert() [2/4]

template<typename RecordT>

template<typename InputIterator >

void lsst::afw::table::CatalogT< RecordT >::insert ( SchemaMapper const &  mapper, iterator  pos, InputIterator  first, InputIterator  last  )

inlineinherited

Insert a range of records into the catalog by copying them with a SchemaMapper.

Definition at line 534 of file Catalog.h.

                                                                                                   {
        if (!_table->getSchema().contains(mapper.getOutputSchema())) {
            throw LSST_EXCEPT(pex::exceptions::InvalidParameterError,
                              "SchemaMapper's output schema does not match catalog's schema");
        }
        _maybeReserve(pos, first, last, true,
                      (typename std::iterator_traits<InputIterator>::iterator_category*)0);
        while (first != last) {
            pos = insert(pos, _table->copyRecord(*first, mapper));
            ++pos;
            ++first;
        }
    }

insert() [3/4]

template<typename RecordT>

iterator lsst::afw::table::CatalogT< RecordT >::insert ( iterator  pos, Record const &  r  )

inlineinherited

Insert a copy of the given record at the given position.

Definition at line 549 of file Catalog.h.

                                                   {
        std::shared_ptr<RecordT> p = _table->copyRecord(r);
        return iterator(_internal.insert(pos.base(), p));
    }

insert() [4/4]

template<typename RecordT>

iterator lsst::afw::table::CatalogT< RecordT >::insert ( iterator  pos, std::shared_ptr< RecordT > const &  p  )

inlineinherited

Insert the given record at the given position without copying.

Definition at line 555 of file Catalog.h.

                                                                   {
        return iterator(_internal.insert(pos.base(), p));
    }

isContiguous()

template<typename RecordT>

bool lsst::afw::table::CatalogT< RecordT >::isContiguous ( ) const

inlineinherited

Return true if all records are contiguous.

Definition at line 388 of file Catalog.h.

{ return ColumnView::isRangeContiguous(_table, begin(), end()); }

isSorted() [1/3]

template<typename RecordT>

bool lsst::afw::table::SortedCatalogT< RecordT >::isSorted ( ) const

inlineinherited

Return true if the vector is in ascending ID order.

Definition at line 63 of file SortedCatalog.h.

{ return this->isSorted(Table::getIdKey()); }

isSorted() [2/3]

template<typename RecordT >

template<typename T >

bool lsst::afw::table::CatalogT< RecordT >::isSorted ( Key< T > const &  key ) const

inherited

Return true if the catalog is in ascending order according to the given key.

Definition at line 742 of file Catalog.h.

                                                        {
    detail::KeyComparisonFunctor<RecordT, T> f = {key};
    return isSorted(f);
}

isSorted() [3/3]

template<typename RecordT >

template<typename Compare >

bool lsst::afw::table::CatalogT< RecordT >::isSorted ( Compare  cmp ) const

inherited

Return true if the catalog is in ascending order according to the given predicate.

cmp(a, b) should return true if record a is less than record b, and false otherwise.

TODO: C++11 has an is_sorted function we should use when available.

Definition at line 719 of file Catalog.h.

                                                  {
    detail::ComparisonAdaptor<RecordT, Compare> f = {cmp};
    if (empty()) return true;
    const_iterator last = this->begin();
    const_iterator i = last;
    ++i;
    for (; i != this->end(); ++i) {
        if (f(i, last)) return false;
        last = i;
    }
    return true;
}

lower_bound() [1/2]

template<typename RecordT >

template<typename T >

CatalogT< RecordT >::iterator lsst::afw::table::CatalogT< RecordT >::lower_bound ( typename Field< T >::Value const &  value, Key< T > const &  key  )

inherited

Performed binary searches on sorted fields.

These methods perform binary searches analogous to the STL algorithms of the same name; they simply create a comparison functor using the given value and Key.

In Python, the lower_bound and upper_bound methods return the position of the result record in the catalog, and equal_range returns a Python slice object that defines the range.

Note

The catalog must be sorted in ascending order according to the given key before calling any of the search methods (i.e. isSorted(key) must be true).

Definition at line 782 of file Catalog.h.

                                                                                       {
    detail::KeyExtractionFunctor<RecordT, T> f = {key};
    // Iterator adaptor that makes a CatalogT iterator work like an iterator over field values.
    typedef boost::transform_iterator<detail::KeyExtractionFunctor<RecordT, T>, iterator> SearchIter;
    SearchIter i = std::lower_bound(SearchIter(begin(), f), SearchIter(end(), f), value);
    return i.base();
}

lower_bound() [2/2]

template<typename RecordT >

template<typename T >

CatalogT< RecordT >::const_iterator lsst::afw::table::CatalogT< RecordT >::lower_bound ( typename Field< T >::Value const &  value, Key< T > const &  key  ) const

inherited

Performed binary searches on sorted fields.

These methods perform binary searches analogous to the STL algorithms of the same name; they simply create a comparison functor using the given value and Key.

In Python, the lower_bound and upper_bound methods return the position of the result record in the catalog, and equal_range returns a Python slice object that defines the range.

Note

The catalog must be sorted in ascending order according to the given key before calling any of the search methods (i.e. isSorted(key) must be true).

Definition at line 793 of file Catalog.h.

                                                                      {
    detail::KeyExtractionFunctor<RecordT, T> f = {key};
    // Iterator adaptor that makes a CatalogT iterator work like an iterator over field values.
    typedef boost::transform_iterator<detail::KeyExtractionFunctor<RecordT, T>, const_iterator> SearchIter;
    SearchIter i = std::lower_bound(SearchIter(begin(), f), SearchIter(end(), f), value);
    return i.base();
}

max_size()

template<typename RecordT>

size_type lsst::afw::table::CatalogT< RecordT >::max_size ( ) const

inlineinherited

Return the maximum number of elements allowed in a catalog.

Definition at line 411 of file Catalog.h.

{ return _internal.max_size(); }

operator=() [1/2]

template<typename RecordT>

ExposureCatalogT& lsst::afw::table::ExposureCatalogT< RecordT >::operator= ( ExposureCatalogT< RecordT > const &  )

default

operator=() [2/2]

template<typename RecordT>

ExposureCatalogT& lsst::afw::table::ExposureCatalogT< RecordT >::operator= ( ExposureCatalogT< RecordT > &&  )

default

operator[]()

template<typename RecordT>

reference lsst::afw::table::CatalogT< RecordT >::operator[] ( size_type  i ) const

inlineinherited

Return the record at index i.

Definition at line 447 of file Catalog.h.

{ return *_internal[i]; }

pop_back()

template<typename RecordT>

void lsst::afw::table::CatalogT< RecordT >::pop_back ( )

inlineinherited

Remove the last record in the catalog.

Definition at line 492 of file Catalog.h.

{ _internal.pop_back(); }

push_back() [1/2]

template<typename RecordT>

void lsst::afw::table::CatalogT< RecordT >::push_back ( Record const &  r )

inlineinherited

Add a copy of the given record to the end of the catalog.

Definition at line 476 of file Catalog.h.

                                    {
        std::shared_ptr<RecordT> p = _table->copyRecord(r);
        _internal.push_back(p);
    }

push_back() [2/2]

template<typename RecordT>

void lsst::afw::table::CatalogT< RecordT >::push_back ( std::shared_ptr< RecordT > const &  p )

inlineinherited

Add the given record to the end of the catalog without copying.

Definition at line 482 of file Catalog.h.

{ _internal.push_back(p); }

readFits() [1/4]

template<typename RecordT>

static ExposureCatalogT lsst::afw::table::ExposureCatalogT< RecordT >::readFits ( std::string const &  filename, int  hdu = fits::DEFAULT_HDU, int  flags = 0  )

inlinestatic

Read a FITS binary table from a regular file.

Parameters

[in]	filename	Name of the file to read.
[in]	hdu	Number of the "header-data unit" to read (where 0 is the Primary HDU). The default value of afw::fits::DEFAULT_HDU is interpreted as "the first HDU with NAXIS != 0".
[in]	flags	Table-subclass-dependent bitflags that control the details of how to read the catalog. See e.g. SourceFitsFlags.

Definition at line 386 of file Exposure.h.

                                                    {
        return io::FitsReader::apply<ExposureCatalogT>(filename, hdu, flags);
    }

readFits() [2/4]

template<typename RecordT>

static ExposureCatalogT lsst::afw::table::ExposureCatalogT< RecordT >::readFits ( fits::MemFileManager &  manager, int  hdu = fits::DEFAULT_HDU, int  flags = 0  )

inlinestatic

Read a FITS binary table from a RAM file.

Parameters

[in]	manager	Object that manages the memory to be read.
[in]	hdu	Number of the "header-data unit" to read (where 0 is the Primary HDU). The default value of afw::fits::DEFAULT_HDU is interpreted as "the first HDU with NAXIS != 0".
[in]	flags	Table-subclass-dependent bitflags that control the details of how to read the catalog. See e.g. SourceFitsFlags.

Definition at line 401 of file Exposure.h.

                                                    {
        return io::FitsReader::apply<ExposureCatalogT>(manager, hdu, flags);
    }

readFits() [3/4]

template<typename RecordT>

static ExposureCatalogT lsst::afw::table::ExposureCatalogT< RecordT >::readFits ( fits::Fits &  fitsfile, int  flags = 0  )

inlinestatic

Read a FITS binary table from a file object already at the correct extension.

Parameters

[in]	fitsfile	Fits file object to read from.
[in]	flags	Table-subclass-dependent bitflags that control the details of how to read the catalog. See e.g. SourceFitsFlags.

Definition at line 413 of file Exposure.h.

                                                                        {
        return io::FitsReader::apply<ExposureCatalogT>(fitsfile, flags);
    }

readFits() [4/4]

template<typename RecordT>

static ExposureCatalogT lsst::afw::table::ExposureCatalogT< RecordT >::readFits ( fits::Fits &  fitsfile, std::shared_ptr< io::InputArchive >  archive, int  flags = 0  )

inlinestatic

Read a FITS binary table from a file object already at the correct extension.

This overload reads nested Persistables from the given archive instead of loading a new archive from the HDUs following the catalog.

Definition at line 423 of file Exposure.h.

                                                    {
        return io::FitsReader::apply<ExposureCatalogT>(fitsfile, flags, archive);
    }

readFromArchive()

template<typename RecordT >

ExposureCatalogT< RecordT > lsst::afw::table::ExposureCatalogT< RecordT >::readFromArchive ( io::InputArchive const &  archive, BaseCatalog const &  catalog  )

static

Convenience input function for Persistables that contain an ExposureCatalog.

Unlike the FITS read methods, this reader is not polymorphically aware - it always tries to create an ExposureTable rather than infer the type of table from the data.

Definition at line 456 of file Exposure.cc.

                                                                                                 {
    // Helper constructor will infer which components are available
    // (effectively the version, but more flexible).
    PersistenceHelper helper{catalog.getSchema()};
    SchemaMapper mapper = helper.makeReadMapper(catalog.getSchema());
    ExposureCatalogT<ExposureRecord> result(mapper.getOutputSchema());
    result.reserve(catalog.size());
    for (BaseCatalog::const_iterator i = catalog.begin(); i != catalog.end(); ++i) {
        helper.readRecord(*i, *result.addNew(), mapper, archive);
    }
    return result;
}

reserve()

template<typename RecordT>

void lsst::afw::table::CatalogT< RecordT >::reserve ( size_type  n )

inlineinherited

Increase the capacity of the catalog to the given size.

This can be used to guarantee that the catalog will be contiguous, but it only affects records constructed after reserve().

Definition at line 428 of file Catalog.h.

                              {
        if (n <= _internal.size()) return;
        _table->preallocate(n - _internal.size());
        _internal.reserve(n);
    }

resize()

template<typename RecordT>

void lsst::afw::table::CatalogT< RecordT >::resize ( size_type  n )

inlineinherited

Change the size of the catalog, removing or adding empty records as needed.

Definition at line 435 of file Catalog.h.

                             {
        size_type old = size();
        _internal.resize(n);
        if (old < n) {
            _table->preallocate(n - old);
            for (size_type i = old; i != n; ++i) {
                _internal[i] = _table->makeRecord();
            }
        }
    }

set()

template<typename RecordT>

void lsst::afw::table::CatalogT< RecordT >::set ( size_type  i, std::shared_ptr< RecordT > const &  p  )

inlineinherited

Set the record at index i to a pointer.

Definition at line 462 of file Catalog.h.

{ _internal[i] = p; }

size()

template<typename RecordT>

size_type lsst::afw::table::CatalogT< RecordT >::size ( ) const

inlineinherited

Return the number of elements in the catalog.

Definition at line 408 of file Catalog.h.

{ return _internal.size(); }

sort() [1/3]

template<typename RecordT>

void lsst::afw::table::SortedCatalogT< RecordT >::sort ( )

inlineinherited

Sort the vector in-place by ID.

Definition at line 66 of file SortedCatalog.h.

{ this->sort(Table::getIdKey()); }

sort() [2/3]

template<typename RecordT >

template<typename T >

void lsst::afw::table::CatalogT< RecordT >::sort ( Key< T > const &  key )

inherited

Sort the catalog in-place by the field with the given key.

Definition at line 749 of file Catalog.h.

                                              {
    detail::KeyComparisonFunctor<RecordT, T> f = {key};
    return sort(f);
}

sort() [3/3]

template<typename RecordT >

template<typename Compare >

void lsst::afw::table::CatalogT< RecordT >::sort ( Compare  cmp )

inherited

Sort the catalog in-place by the field with the given predicate.

cmp(a, b) should return true if record a is less than record b, and false otherwise.

Definition at line 735 of file Catalog.h.

                                        {
    detail::ComparisonAdaptor<RecordT, Compare> f = {cmp};
    std::stable_sort(_internal.begin(), _internal.end(), f);
}

subset() [1/2]

template<typename RecordT>

ExposureCatalogT<RecordT> lsst::afw::table::ExposureCatalogT< RecordT >::subset ( ndarray::Array< bool const, 1 > const &  mask ) const

inline

Return the subset of a catalog corresponding to the True values of the given mask array.

The returned array's records are shallow copies, and hence will not in general be contiguous.

Definition at line 450 of file Exposure.h.

                                                                                    {
        return ExposureCatalogT(Base::subset(mask));
    }

subset() [2/2]

template<typename RecordT>

ExposureCatalogT lsst::afw::table::ExposureCatalogT< RecordT >::subset ( std::ptrdiff_t  startd, std::ptrdiff_t  stopd, std::ptrdiff_t  step  ) const

inline

Shallow copy a subset of another ExposureCatalog.

Mostly here for use from python.

Definition at line 458 of file Exposure.h.

                                                                                              {
        return ExposureCatalogT(Base::subset(startd, stopd, step));
    }

subsetContaining() [1/2]

template<typename RecordT >

ExposureCatalogT< RecordT > lsst::afw::table::ExposureCatalogT< RecordT >::subsetContaining	(	lsst::geom::SpherePoint const &	coord,
		bool	includeValidPolygon = false
	)		const

Return a shallow subset of the catalog with only those records that contain the given point.

If includeValidPolygon is true we check that the point is within the validPolygon of those records which have one; if they don't, this argument is ignored.

See also

ExposureRecord::contains

Definition at line 471 of file Exposure.cc.

                                                                                                      {
    ExposureCatalogT result(this->getTable());
    for (const_iterator i = this->begin(); i != this->end(); ++i) {
        if (i->contains(coord, includeValidPolygon)) {
            result.push_back(i);
        }
    }
    return result;
}

subsetContaining() [2/2]

template<typename RecordT >

ExposureCatalogT< RecordT > lsst::afw::table::ExposureCatalogT< RecordT >::subsetContaining	(	lsst::geom::Point2D const &	point,
		geom::SkyWcs const &	wcs,
		bool	includeValidPolygon = false
	)		const

Return a shallow subset of the catalog with only those records that contain the given point.

If includeValidPolygon is true we check that the point is within the validPolygon of those records which have one; if they don't, this argument is ignored.

See also

ExposureRecord::contains

Definition at line 483 of file Exposure.cc.

                                                                                                      {
    ExposureCatalogT result(this->getTable());
    for (const_iterator i = this->begin(); i != this->end(); ++i) {
        if (i->contains(point, wcs, includeValidPolygon)) {
            result.push_back(i);
        }
    }
    return result;
}

swap()

template<typename RecordT>

void lsst::afw::table::CatalogT< RecordT >::swap ( CatalogT< RecordT > &  other )

inlinenoexceptinherited

Shallow swap of two catalogs.

Definition at line 568 of file Catalog.h.

                                        {
        _table.swap(other._table);
        _internal.swap(other._internal);
    }

upper_bound() [1/2]

template<typename RecordT >

template<typename T >

CatalogT< RecordT >::iterator lsst::afw::table::CatalogT< RecordT >::upper_bound ( typename Field< T >::Value const &  value, Key< T > const &  key  )

inherited

Performed binary searches on sorted fields.

These methods perform binary searches analogous to the STL algorithms of the same name; they simply create a comparison functor using the given value and Key.

In Python, the lower_bound and upper_bound methods return the position of the result record in the catalog, and equal_range returns a Python slice object that defines the range.

Note

The catalog must be sorted in ascending order according to the given key before calling any of the search methods (i.e. isSorted(key) must be true).

Definition at line 804 of file Catalog.h.

                                                                                       {
    detail::KeyExtractionFunctor<RecordT, T> f = {key};
    // Iterator adaptor that makes a CatalogT iterator work like an iterator over field values.
    typedef boost::transform_iterator<detail::KeyExtractionFunctor<RecordT, T>, iterator> SearchIter;
    SearchIter i = std::upper_bound(SearchIter(begin(), f), SearchIter(end(), f), value);
    return i.base();
}

upper_bound() [2/2]

template<typename RecordT >

template<typename T >

CatalogT< RecordT >::const_iterator lsst::afw::table::CatalogT< RecordT >::upper_bound ( typename Field< T >::Value const &  value, Key< T > const &  key  ) const

inherited

Performed binary searches on sorted fields.

These methods perform binary searches analogous to the STL algorithms of the same name; they simply create a comparison functor using the given value and Key.

In Python, the lower_bound and upper_bound methods return the position of the result record in the catalog, and equal_range returns a Python slice object that defines the range.

Note

The catalog must be sorted in ascending order according to the given key before calling any of the search methods (i.e. isSorted(key) must be true).

Definition at line 815 of file Catalog.h.

                                                                      {
    detail::KeyExtractionFunctor<RecordT, T> f = {key};
    // Iterator adaptor that makes a CatalogT iterator work like an iterator over field values.
    typedef boost::transform_iterator<detail::KeyExtractionFunctor<RecordT, T>, const_iterator> SearchIter;
    SearchIter i = std::upper_bound(SearchIter(begin(), f), SearchIter(end(), f), value);
    return i.base();
}

writeFits() [1/4]

template<typename RecordT>

void lsst::afw::table::CatalogT< RecordT >::writeFits ( std::string const &  filename, std::string const &  mode = "w", int  flags = 0  ) const

inlineinherited

Write a FITS binary table to a regular file.

Parameters

[in]	filename	Name of the file to write.
[in]	mode	"a" to append a new HDU, "w" to overwrite any existing file.
[in]	flags	Table-subclass-dependent bitflags that control the details of how to read the catalogs. See e.g. SourceFitsFlags.

Definition at line 306 of file Catalog.h.

                                                                                                {
        io::FitsWriter::apply(filename, mode, *this, flags);
    }

writeFits() [2/4]

template<typename RecordT>

void lsst::afw::table::CatalogT< RecordT >::writeFits ( fits::MemFileManager &  manager, std::string const &  mode = "w", int  flags = 0  ) const

inlineinherited

Write a FITS binary table to a RAM file.

Parameters

[in,out]	manager	Object that manages the memory to write to.
[in]	mode	"a" to append a new HDU, "w" to overwrite any existing file.
[in]	flags	Table-subclass-dependent bitflags that control the details of how to read the catalogs. See e.g. SourceFitsFlags.

Definition at line 318 of file Catalog.h.

                                                                                                  {
        io::FitsWriter::apply(manager, mode, *this, flags);
    }

writeFits() [3/4]

template<typename RecordT>

void lsst::afw::table::CatalogT< RecordT >::writeFits ( fits::Fits &  fitsfile, int  flags = 0  ) const

inlineinherited

Write a FITS binary table to an open file object.

Parameters

[in,out]	fitsfile	Fits file object to write to.
[in]	flags	Table-subclass-dependent bitflags that control the details of how to read the catalogs. See e.g. SourceFitsFlags.

Definition at line 329 of file Catalog.h.

                                                            {
        io::FitsWriter::apply(fitsfile, *this, flags);
    }

writeFits() [4/4]

template<typename RecordT>

void lsst::afw::table::ExposureCatalogT< RecordT >::writeFits ( fits::Fits &  fitsfile, std::shared_ptr< io::OutputArchive >  archive, int  flags = 0  ) const

inline

Write a FITS binary table to an open file object.

Instead of writing nested Persistables to an internal archive and appending it to the FITS file, this overload inserts nested Persistables into the given archive and does not save it, leaving it to the user to save it later.

Definition at line 371 of file Exposure.h.

                                                                                                    {
        std::shared_ptr<io::FitsWriter> writer = this->getTable()->makeFitsWriter(&fitsfile, archive, flags);
        writer->write(*this);
    }

writeToArchive()

template<typename RecordT >

void lsst::afw::table::ExposureCatalogT< RecordT >::writeToArchive	(	io::OutputArchiveHandle &	handle,
		bool	ignoreUnpersistable = true
	)		const

Convenience output function for Persistables that contain an ExposureCatalog.

Unlike writeFits, this saves main catalog to one of the tables within the archive, as part of a Persistable's set of catalogs, rather than saving it to a separate HDU not managed by the archive.

Definition at line 444 of file Exposure.cc.

                                                                                                   {
    PersistenceHelper helper{};
    SchemaMapper mapper = helper.makeWriteMapper(this->getSchema());
    BaseCatalog outputCat = handle.makeCatalog(mapper.getOutputSchema());
    outputCat.reserve(this->size());
    for (const_iterator i = this->begin(); i != this->end(); ++i) {
        helper.writeRecord(*i, *outputCat.addNew(), mapper, handle, permissive);
    }
    handle.saveCatalog(outputCat);
}

---

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

• /j/snowflake/release/lsstsw/stack/Linux64/afw/19.0.0-4-ga671dab3b+1/include/lsst/afw/table/Exposure.h
• /j/snowflake/release/lsstsw/stack/Linux64/afw/19.0.0-4-ga671dab3b+1/src/table/Exposure.cc