LSSTApplications  19.0.0-10-g920eed2,19.0.0-11-g48a0200+2,19.0.0-18-gfc4e62b+10,19.0.0-2-g3b2f90d+2,19.0.0-2-gd671419+5,19.0.0-20-g5a5a17ab+8,19.0.0-21-g2644856+10,19.0.0-22-gc5dc5b1+5,19.0.0-23-gdc29a50+2,19.0.0-24-g923e380+10,19.0.0-25-g6c8df7140,19.0.0-27-g567f04d+6,19.0.0-3-g2b32d65+5,19.0.0-3-g8227491+9,19.0.0-3-g9c54d0d+9,19.0.0-3-gca68e65+5,19.0.0-3-gcfc5f51+5,19.0.0-3-ge110943+8,19.0.0-3-ge74d124,19.0.0-3-gfe04aa6+10,19.0.0-4-g06f5963+5,19.0.0-4-g3d16501+10,19.0.0-4-g4a9c019+5,19.0.0-4-g5a8b323,19.0.0-4-g66397f0+1,19.0.0-4-g8278b9b+1,19.0.0-4-g8557e14,19.0.0-4-g8964aba+10,19.0.0-4-ge404a01+9,19.0.0-5-g40f3a5a,19.0.0-5-g4db63b3,19.0.0-5-gfb03ce7+10,19.0.0-6-gbaebbfb+9,19.0.0-60-gafafd468+10,19.0.0-64-gf672fef+7,19.0.0-7-g039c0b5+8,19.0.0-7-gbea9075+4,19.0.0-7-gc567de5+10,19.0.0-8-g3a3ce09+5,19.0.0-9-g463f923+9,w.2020.21
LSSTDataManagementBasePackage
Public Types | Public Member Functions | Static Public Member Functions | List of all members
lsst::afw::table::CatalogT< RecordT > Class Template Reference

A custom container class for records, based on std::vector. More...

#include <Catalog.h>

Public Types

typedef RecordT Record
 
typedef Record::Table Table
 
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
 
typedef CatalogIterator< typename Internal::iterator > iterator
 
typedef CatalogIterator< typename Internal::const_iterator > const_iterator
 

Public Member Functions

std::shared_ptr< TablegetTable () const
 Return the table associated with the catalog. More...
 
Schema getSchema () const
 Return the schema associated with the catalog's table. More...
 
 CatalogT (std::shared_ptr< Table > const &table=std::shared_ptr< Table >())
 Construct a catalog from a table (or nothing). More...
 
 CatalogT (Schema const &schema)
 Construct a catalog from a schema, creating a table with Table::make(schema). More...
 
template<typename InputIterator >
 CatalogT (std::shared_ptr< Table > const &table, InputIterator first, InputIterator last, bool deep=false)
 Construct a catalog from a table and an iterator range. More...
 
 CatalogT (CatalogT const &other)
 Shallow copy constructor. More...
 
 CatalogT (CatalogT &&other)
 
 ~CatalogT ()=default
 
template<typename OtherRecordT >
 CatalogT (CatalogT< OtherRecordT > const &other)
 Shallow copy constructor from a container containing a related record type. More...
 
CatalogToperator= (CatalogT const &other)
 Shallow assigment. More...
 
CatalogToperator= (CatalogT &&other)
 
CatalogT< 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...
 
CatalogT< RecordT > subset (std::ptrdiff_t startd, std::ptrdiff_t stopd, std::ptrdiff_t step) const
 Returns a shallow copy of a subset of this Catalog. 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...
 
iterator begin ()
 Iterator access. More...
 
iterator end ()
 
const_iterator begin () const
 
const_iterator end () const
 
const_iterator cbegin () const
 
const_iterator cend () const
 
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 >
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...
 
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...
 
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
 
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
 
template<typename T >
iterator upper_bound (typename Field< T >::Value const &value, Key< T > const &key)
 
template<typename T >
const_iterator upper_bound (typename Field< T >::Value const &value, Key< T > const &key) const
 
template<typename T >
std::pair< iterator, iteratorequal_range (typename Field< T >::Value const &value, Key< T > const &key)
 
template<typename T >
std::pair< const_iterator, const_iteratorequal_range (typename Field< T >::Value const &value, Key< T > const &key) const
 
InternalgetInternal ()
 Return a reference to the internal vector-of-shared_ptr. More...
 
Internal const & getInternal () const
 
template<typename T >
std::pair< typename CatalogT< RecordT >::iterator, typename CatalogT< RecordT >::iteratorequal_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_iteratorequal_range (typename Field< T >::Value const &value, Key< T > const &key) const
 

Static Public Member Functions

static CatalogT readFits (std::string const &filename, int hdu=fits::DEFAULT_HDU, int flags=0)
 Read a FITS binary table from a regular file. More...
 
static CatalogT readFits (fits::MemFileManager &manager, int hdu=fits::DEFAULT_HDU, int flags=0)
 Read a FITS binary table from a RAM file. More...
 
static CatalogT readFits (fits::Fits &fitsfile, int flags=0)
 Read a FITS binary table from a file object already at the correct extension. More...
 

Detailed Description

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

A custom container class for records, based on std::vector.

CatalogT wraps a std::vector<std::shared_ptr<RecordT>> in an interface that looks more like a std::vector<RecordT>; its iterators and accessors return references or const references, rather than pointers, making them easier to use. It also holds a table, which is used to allocate new records and determine the schema, but no checking is done to ensure that records added to the catalog use the same table or indeed have the same schema.

Because a CatalogT is holds shared_ptrs internally, many of its operations can be either shallow or deep, with new deep copies allocated by the catalog's table object. New records can be also be inserted by pointer (shallow) or by value (deep).

The constness of records is determined by the constness of the first template parameter to CatalogT; a container instance is always either const or non-const in that respect (like smart pointers). Also like smart pointers, const member functions (and by extension, const_iterators) do not allow the underlying pointers to be changed, while non-const member functions and iterators do.

CatalogT does not permit empty (null) pointers as elements. As a result, CatalogT has no resize member function.

CatalogT has a very different interface in Python; it mimics Python's list instead of C++'s std::vector. It is also considerably simpler, because it doesn't need to deal with iterator ranges or the distinction between references and shared_ptrs to records. See the Python docstring for more information.

Definition at line 97 of file Catalog.h.

Member Typedef Documentation

◆ ColumnView

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

Definition at line 103 of file Catalog.h.

◆ const_iterator

template<typename RecordT >
typedef CatalogIterator<typename Internal::const_iterator> lsst::afw::table::CatalogT< RecordT >::const_iterator

Definition at line 111 of file Catalog.h.

◆ difference_type

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

Definition at line 109 of file Catalog.h.

◆ iterator

template<typename RecordT >
typedef CatalogIterator<typename Internal::iterator> lsst::afw::table::CatalogT< RecordT >::iterator

Definition at line 110 of file Catalog.h.

◆ pointer

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

Definition at line 107 of file Catalog.h.

◆ Record

template<typename RecordT >
typedef RecordT lsst::afw::table::CatalogT< RecordT >::Record

Definition at line 101 of file Catalog.h.

◆ reference

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

Definition at line 106 of file Catalog.h.

◆ size_type

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

Definition at line 108 of file Catalog.h.

◆ Table

template<typename RecordT >
typedef Record::Table lsst::afw::table::CatalogT< RecordT >::Table

Definition at line 102 of file Catalog.h.

◆ value_type

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

Definition at line 105 of file Catalog.h.

Constructor & Destructor Documentation

◆ CatalogT() [1/6]

template<typename RecordT >
lsst::afw::table::CatalogT< RecordT >::CatalogT ( std::shared_ptr< Table > const &  table = std::shared_ptr<Table>())
inlineexplicit

Construct a catalog from a table (or nothing).

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

Definition at line 125 of file Catalog.h.

126  : _table(table), _internal() {}

◆ CatalogT() [2/6]

template<typename RecordT >
lsst::afw::table::CatalogT< RecordT >::CatalogT ( Schema const &  schema)
inlineexplicit

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

Definition at line 129 of file Catalog.h.

129 : _table(Table::make(schema)), _internal() {}

◆ CatalogT() [3/6]

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

Construct a catalog 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 142 of file Catalog.h.

143  : _table(table), _internal() {
144  insert(end(), first, last, deep);
145  }

◆ CatalogT() [4/6]

template<typename RecordT >
lsst::afw::table::CatalogT< RecordT >::CatalogT ( CatalogT< RecordT > const &  other)
inline

Shallow copy constructor.

Definition at line 148 of file Catalog.h.

148 : _table(other._table), _internal(other._internal) {}

◆ CatalogT() [5/6]

template<typename RecordT >
lsst::afw::table::CatalogT< RecordT >::CatalogT ( CatalogT< RecordT > &&  other)
inline

Definition at line 150 of file Catalog.h.

150 : CatalogT(other) {}

◆ ~CatalogT()

template<typename RecordT >
lsst::afw::table::CatalogT< RecordT >::~CatalogT ( )
default

◆ CatalogT() [6/6]

template<typename RecordT >
template<typename OtherRecordT >
lsst::afw::table::CatalogT< RecordT >::CatalogT ( CatalogT< 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 161 of file Catalog.h.

162  : _table(other.getTable()), _internal(other.begin().base(), other.end().base()) {}

Member Function Documentation

◆ addNew()

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

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.

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

◆ assign()

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

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.

470  {
471  clear();
472  insert(end(), first, last, deep);
473  }

◆ at()

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

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

Definition at line 450 of file Catalog.h.

450 { return *_internal.at(i); }

◆ back()

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

Return the last record.

Definition at line 456 of file Catalog.h.

456 { return *_internal.back(); }

◆ begin() [1/2]

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

Iterator access.

See also
CatalogIterator

Definition at line 396 of file Catalog.h.

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

◆ begin() [2/2]

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

Definition at line 398 of file Catalog.h.

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

◆ capacity()

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

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.

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

◆ cbegin()

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

Definition at line 400 of file Catalog.h.

400 { return begin(); }

◆ cend()

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

Definition at line 401 of file Catalog.h.

401 { return end(); }

◆ clear()

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

Remove all records from the catalog.

Definition at line 574 of file Catalog.h.

574 { _internal.clear(); }

◆ copy()

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

Deep-copy the catalog using a cloned table.

Definition at line 495 of file Catalog.h.

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

◆ empty()

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

Return true if the catalog has no records.

Definition at line 405 of file Catalog.h.

405 { return _internal.empty(); }

◆ end() [1/2]

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

Definition at line 397 of file Catalog.h.

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

◆ end() [2/2]

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

Definition at line 399 of file Catalog.h.

399 { 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 
)

◆ equal_range() [2/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 
)

Definition at line 827 of file Catalog.h.

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

◆ equal_range() [3/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

◆ 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

Definition at line 839 of file Catalog.h.

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

◆ erase() [1/2]

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

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

Definition at line 563 of file Catalog.h.

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

◆ erase() [2/2]

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

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

Definition at line 560 of file Catalog.h.

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

◆ find() [1/2]

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 
)

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.

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

◆ find() [2/2]

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

Definition at line 769 of file Catalog.h.

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

◆ front()

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

Return the first record.

Definition at line 453 of file Catalog.h.

453 { return *_internal.front(); }

◆ get()

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

Return a pointer to the record at index i.

Definition at line 459 of file Catalog.h.

459 { return _internal[i]; }

◆ getColumnView()

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

Return a ColumnView of this catalog's records.

Will throw RuntimeError if records are not contiguous.

Definition at line 377 of file Catalog.h.

377  {
379  throw LSST_EXCEPT(
380  pex::exceptions::LogicError,
381  "Cannot get a column view from a CatalogT<RecordT const> (as column views are always "
382  "non-const views).");
383  }
384  return ColumnView::make(_table, begin(), end());
385  }

◆ getInternal() [1/2]

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

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.

669 { return _internal; }

◆ getInternal() [2/2]

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

Definition at line 670 of file Catalog.h.

670 { return _internal; }

◆ getSchema()

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

Return the schema associated with the catalog's table.

Definition at line 117 of file Catalog.h.

117 { return _table->getSchema(); }

◆ getTable()

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

Return the table associated with the catalog.

Definition at line 114 of file Catalog.h.

114 { 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 
)
inline

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.

513  {
514  _maybeReserve(pos, first, last, deep,
516  if (deep) {
517  while (first != last) {
518  pos = insert(pos, *first);
519  ++pos;
520  ++first;
521  }
522  } else {
523  while (first != last) {
524  pos = insert(pos, first);
525  assert(pos != end());
526  ++pos;
527  ++first;
528  }
529  }
530  }

◆ insert() [2/4]

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

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

Definition at line 549 of file Catalog.h.

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

◆ insert() [3/4]

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

Insert the given record at the given position without copying.

Definition at line 555 of file Catalog.h.

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

◆ insert() [4/4]

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

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

Definition at line 534 of file Catalog.h.

534  {
535  if (!_table->getSchema().contains(mapper.getOutputSchema())) {
536  throw LSST_EXCEPT(pex::exceptions::InvalidParameterError,
537  "SchemaMapper's output schema does not match catalog's schema");
538  }
539  _maybeReserve(pos, first, last, true,
541  while (first != last) {
542  pos = insert(pos, _table->copyRecord(*first, mapper));
543  ++pos;
544  ++first;
545  }
546  }

◆ isContiguous()

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

Return true if all records are contiguous.

Definition at line 388 of file Catalog.h.

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

◆ isSorted() [1/2]

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

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.

719  {
721  detail::ComparisonAdaptor<RecordT, Compare> f = {cmp};
722  if (empty()) return true;
723  const_iterator last = this->begin();
724  const_iterator i = last;
725  ++i;
726  for (; i != this->end(); ++i) {
727  if (f(i, last)) return false;
728  last = i;
729  }
730  return true;
731 }

◆ isSorted() [2/2]

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

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

Definition at line 742 of file Catalog.h.

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

◆ 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 
)

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.

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

◆ 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

Definition at line 793 of file Catalog.h.

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

◆ max_size()

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

Return the maximum number of elements allowed in a catalog.

Definition at line 411 of file Catalog.h.

411 { return _internal.max_size(); }

◆ operator=() [1/2]

template<typename RecordT >
CatalogT& lsst::afw::table::CatalogT< RecordT >::operator= ( CatalogT< RecordT > &&  other)
inline

Definition at line 173 of file Catalog.h.

173 { return *this = other; }

◆ operator=() [2/2]

template<typename RecordT >
CatalogT& lsst::afw::table::CatalogT< RecordT >::operator= ( CatalogT< RecordT > const &  other)
inline

Shallow assigment.

Definition at line 165 of file Catalog.h.

165  {
166  if (&other != this) {
167  _table = other._table;
168  _internal = other._internal;
169  }
170  return *this;
171  }

◆ operator[]()

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

Return the record at index i.

Definition at line 447 of file Catalog.h.

447 { return *_internal[i]; }

◆ pop_back()

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

Remove the last record in the catalog.

Definition at line 492 of file Catalog.h.

492 { _internal.pop_back(); }

◆ push_back() [1/2]

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

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

Definition at line 476 of file Catalog.h.

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

◆ push_back() [2/2]

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

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

Definition at line 482 of file Catalog.h.

482 { _internal.push_back(p); }

◆ readFits() [1/3]

template<typename RecordT >
static CatalogT lsst::afw::table::CatalogT< 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]fitsfileFits file object to read from.
[in]flagsTable-subclass-dependent bitflags that control the details of how to read the catalog. See e.g. SourceFitsFlags.

Definition at line 368 of file Catalog.h.

368  {
369  return io::FitsReader::apply<CatalogT>(fitsfile, flags);
370  }

◆ readFits() [2/3]

template<typename RecordT >
static CatalogT lsst::afw::table::CatalogT< 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]managerObject that manages the memory to be read.
[in]hduNumber 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]flagsTable-subclass-dependent bitflags that control the details of how to read the catalog. See e.g. SourceFitsFlags.

Definition at line 357 of file Catalog.h.

357  {
358  return io::FitsReader::apply<CatalogT>(manager, hdu, flags);
359  }

◆ readFits() [3/3]

template<typename RecordT >
static CatalogT lsst::afw::table::CatalogT< 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]filenameName of the file to read.
[in]hduNumber 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]flagsTable-subclass-dependent bitflags that control the details of how to read the catalog. See e.g. SourceFitsFlags.

Definition at line 343 of file Catalog.h.

343  {
344  return io::FitsReader::apply<CatalogT>(filename, hdu, flags);
345  }

◆ reserve()

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

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.

428  {
429  if (n <= _internal.size()) return;
430  _table->preallocate(n - _internal.size());
431  _internal.reserve(n);
432  }

◆ resize()

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

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

Definition at line 435 of file Catalog.h.

435  {
436  size_type old = size();
437  _internal.resize(n);
438  if (old < n) {
439  _table->preallocate(n - old);
440  for (size_type i = old; i != n; ++i) {
441  _internal[i] = _table->makeRecord();
442  }
443  }
444  }

◆ set()

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

Set the record at index i to a pointer.

Definition at line 462 of file Catalog.h.

462 { _internal[i] = p; }

◆ size()

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

Return the number of elements in the catalog.

Definition at line 408 of file Catalog.h.

408 { return _internal.size(); }

◆ sort() [1/2]

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

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.

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

◆ sort() [2/2]

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

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

Definition at line 749 of file Catalog.h.

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

◆ subset() [1/2]

template<typename RecordT >
CatalogT<RecordT> lsst::afw::table::CatalogT< 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 180 of file Catalog.h.

180  {
181  if (size_type(mask.size()) != size()) {
182  throw LSST_EXCEPT(
183  pex::exceptions::LengthError,
184  (boost::format("Mask array with %d elements applied to catalog with %d elements") %
185  mask.size() % size())
186  .str());
187  }
188  CatalogT<RecordT> result(getTable());
190  const_iterator catIter = begin();
191  for (; maskIter != mask.end(); ++maskIter, ++catIter) {
192  if (*maskIter) result.push_back(catIter);
193  }
194  return result;
195  }

◆ subset() [2/2]

template<typename RecordT >
CatalogT<RecordT> lsst::afw::table::CatalogT< RecordT >::subset ( std::ptrdiff_t  startd,
std::ptrdiff_t  stopd,
std::ptrdiff_t  step 
) const
inline

Returns a shallow copy of a subset of this Catalog.

The arguments correspond to python's slice() syntax.

Definition at line 201 of file Catalog.h.

201  {
202  /* Python's slicing syntax is weird and wonderful.
203 
204  Both the "start" and "stop" indices can be negative, which means the
205  abs() of the index less than the size; [-1] means the last item.
206  Moreover, it's possible to have a negative index less than -len(); it
207  will get clipped. That is in fact one way to slice *backward* through
208  the array *and* include element 0;
209 
210  >>> range(10)[5:-20:-1]
211  [5, 4, 3, 2, 1, 0]
212 
213  The clipping tests in this function look more complicated than they
214  need to be, but that is partly because there are some weird edge cases.
215 
216  Also, ptrdiff_t vs size_t introduces some annoying complexity. Note
217  that the args are "startd"/"stopd" (not "start"/"stop").
218 
219  There is a fairly complete set of tests in tests/ticket2026.py; if you
220  try to simplify this function, be sure they continue to pass.
221  */
222  size_type S = size();
223  size_type start, stop = 0;
224  // Python doesn't allow step == 0
225  if (step == 0) {
226  throw LSST_EXCEPT(pex::exceptions::InvalidParameterError, "Step cannot be zero");
227  }
228  // Basic negative indexing rule: first add size
229  if (startd < 0) {
230  startd += S;
231  }
232  if (stopd < 0) {
233  stopd += S;
234  }
235  // Start gets clipped to zero; stop does not (yet).
236  if (startd < 0) {
237  startd = 0;
238  }
239  // Now start is non-negative, so can cast to size_t.
240  start = (size_type)startd;
241  if (start > S) {
242  start = S;
243  }
244  if (step > 0) {
245  // When stepping forward, stop gets clipped at zero,
246  // so is non-negative and can get cast to size_t.
247  if (stopd < 0) {
248  stopd = 0;
249  }
250  stop = (size_type)stopd;
251  if (stop > S) {
252  stop = S;
253  }
254  } else if (step < 0) {
255  // When stepping backward, stop gets clipped at -1 so that slices
256  // including 0 are possible.
257  if (stopd < 0) {
258  stopd = -1;
259  }
260  }
261 
262  if (((step > 0) && (start >= stop)) || ((step < 0) && ((std::ptrdiff_t)start <= stopd))) {
263  // Empty range
264  return CatalogT<RecordT>(getTable(), begin(), begin());
265  }
266 
267  if (step == 1) {
268  // Use the iterator-based constructor for this simple case
269  assert(start >= 0);
270  assert(stop > 0);
271  assert(start < S);
272  assert(stop <= S);
273  return CatalogT<RecordT>(getTable(), begin() + start, begin() + stop);
274  }
275 
276  // Build a new CatalogT and copy records into it.
277  CatalogT<RecordT> cat(getTable());
278  size_type N = 0;
279  if (step >= 0) {
280  N = (stop - start) / step + (((stop - start) % step) ? 1 : 0);
281  } else {
282  N = (size_t)((stopd - (std::ptrdiff_t)start) / step +
283  (((stopd - (std::ptrdiff_t)start) % step) ? 1 : 0));
284  }
285  cat.reserve(N);
286  if (step >= 0) {
287  for (size_type i = start; i < stop; i += step) {
288  cat.push_back(get(i));
289  }
290  } else {
291  for (std::ptrdiff_t i = (std::ptrdiff_t)start; i > stopd; i += step) {
292  cat.push_back(get(i));
293  }
294  }
295  return cat;
296  }

◆ swap()

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

Shallow swap of two catalogs.

Definition at line 568 of file Catalog.h.

568  {
569  _table.swap(other._table);
570  _internal.swap(other._internal);
571  }

◆ 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 
)

Definition at line 804 of file Catalog.h.

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

◆ 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

Definition at line 815 of file Catalog.h.

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

◆ writeFits() [1/3]

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

Write a FITS binary table to an open file object.

Parameters
[in,out]fitsfileFits file object to write to.
[in]flagsTable-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.

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

◆ writeFits() [2/3]

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

Write a FITS binary table to a RAM file.

Parameters
[in,out]managerObject that manages the memory to write to.
[in]mode"a" to append a new HDU, "w" to overwrite any existing file.
[in]flagsTable-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.

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

◆ writeFits() [3/3]

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

Write a FITS binary table to a regular file.

Parameters
[in]filenameName of the file to write.
[in]mode"a" to append a new HDU, "w" to overwrite any existing file.
[in]flagsTable-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.

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

The documentation for this class was generated from the following file:
schema
table::Schema schema
Definition: Amplifier.cc:115
lsst::afw::table::CatalogT::const_iterator
CatalogIterator< typename Internal::const_iterator > const_iterator
Definition: Catalog.h:111
lsst::afw::table::CatalogT::get
std::shared_ptr< RecordT > const get(size_type i) const
Return a pointer to the record at index i.
Definition: Catalog.h:459
lsst::afw::table::CatalogT::end
iterator end()
Definition: Catalog.h:397
std::vector::resize
T resize(T... args)
lsst::afw::table::CatalogT::empty
bool empty() const
Return true if the catalog has no records.
Definition: Catalog.h:405
std::shared_ptr< RecordT >
lsst::afw::table::CatalogT::size_type
Internal::size_type size_type
Definition: Catalog.h:108
std::pair
std::vector::reserve
T reserve(T... args)
std::vector::size
T size(T... args)
pex.config.history.format
def format(config, name=None, writeSourceLine=True, prefix="", verbose=False)
Definition: history.py:174
lsst::afw::table._match.first
first
Definition: _match.py:76
std::vector::back
T back(T... args)
mask
afw::table::Key< afw::table::Array< MaskPixelT > > mask
Definition: HeavyFootprint.cc:217
std::vector::front
T front(T... args)
std::vector::clear
T clear(T... args)
std::vector::push_back
T push_back(T... args)
lsst::afw::table::CatalogT::size
size_type size() const
Return the number of elements in the catalog.
Definition: Catalog.h:408
std::vector::at
T at(T... args)
std::iterator_traits
other
ItemVariant const * other
Definition: Schema.cc:56
step
int const step
Definition: BoundedField.cc:102
lsst::afw::table::CatalogT::getTable
std::shared_ptr< Table > getTable() const
Return the table associated with the catalog.
Definition: Catalog.h:114
lsst::jointcal::Iterator
FastFinder::Iterator Iterator
Definition: FastFinder.cc:178
lsst::afw::table::CatalogT::iterator
CatalogIterator< typename Internal::iterator > iterator
Definition: Catalog.h:110
lsst::afw::table::CatalogT::isSorted
bool isSorted(Key< T > const &key) const
Return true if the catalog is in ascending order according to the given key.
Definition: Catalog.h:742
lsst::afw::table::CatalogT::clear
void clear()
Remove all records from the catalog.
Definition: Catalog.h:574
std::vector::erase
T erase(T... args)
std::vector::pop_back
T pop_back(T... args)
lsst::afw::table::CatalogT::sort
void sort(Key< T > const &key)
Sort the catalog in-place by the field with the given key.
Definition: Catalog.h:749
std::vector::max_size
T max_size(T... args)
std::upper_bound
T upper_bound(T... args)
result
py::object result
Definition: _schema.cc:429
LSST_EXCEPT
#define LSST_EXCEPT(type,...)
Create an exception with a given type.
Definition: Exception.h:48
std::shared_ptr::swap
T swap(T... args)
lsst::afw::table::CatalogT::insert
void insert(iterator pos, InputIterator first, InputIterator last, bool deep=false)
Insert an iterator range into the table.
Definition: Catalog.h:513
std::equal_range
T equal_range(T... args)
std::lower_bound
T lower_bound(T... args)
std::is_const
std::vector::begin
T begin(T... args)
std::vector::insert
T insert(T... args)
key
Key< U > key
Definition: Schema.cc:281
std::ptrdiff_t
mapper
SchemaMapper * mapper
Definition: SchemaMapper.cc:78
std::vector::empty
T empty(T... args)
lsst::afw::table::CatalogT::CatalogT
CatalogT(std::shared_ptr< Table > const &table=std::shared_ptr< Table >())
Construct a catalog from a table (or nothing).
Definition: Catalog.h:125
std::make_pair
T make_pair(T... args)
std::vector::end
T end(T... args)
std::stable_sort
T stable_sort(T... args)
lsst::afw::table::CatalogT::begin
iterator begin()
Iterator access.
Definition: Catalog.h:396
lsst::afw::image.slicing.clone
clone
Definition: slicing.py:257
lsst::afw::table::io::FitsWriter::apply
static void apply(OutputT &output, std::string const &mode, ContainerT const &container, int flags)
Driver for writing FITS files.
Definition: FitsWriter.h:37