LSSTApplications  10.0-2-g4f67435,11.0.rc2+1,11.0.rc2+12,11.0.rc2+3,11.0.rc2+4,11.0.rc2+5,11.0.rc2+6,11.0.rc2+7,11.0.rc2+8
LSSTDataManagementBasePackage
Catalog.h
Go to the documentation of this file.
1 // -*- lsst-c++ -*-
2 #ifndef AFW_TABLE_Catalog_h_INCLUDED
3 #define AFW_TABLE_Catalog_h_INCLUDED
4 
5 #include <vector>
6 
7 #include "boost/iterator/iterator_adaptor.hpp"
8 #include "boost/iterator/transform_iterator.hpp"
9 
10 #include "lsst/base.h"
11 #include "lsst/pex/exceptions.h"
12 #include "lsst/afw/table/fwd.h"
16 
17 namespace lsst { namespace afw { namespace table {
18 
33 template <typename BaseT>
35  : public boost::iterator_adaptor<CatalogIterator<BaseT>,BaseT,typename BaseT::value_type::element_type>
36 {
37 public:
38 
40 
41  template <typename OtherBaseT>
43  CatalogIterator::iterator_adaptor_(other.base())
44  {}
45 
46  explicit CatalogIterator(BaseT const & base) : CatalogIterator::iterator_adaptor_(base) {}
47 
48  template <typename RecordT>
49  operator PTR(RecordT) () const { return *this->base(); }
50 
51  template <typename RecordT>
52  CatalogIterator & operator=(PTR(RecordT) const & other) const {
53  *this->base() = other;
54  return *this;
55  }
56 
57 private:
59  typename BaseT::value_type::element_type & dereference() const { return **this->base(); }
60 };
61 
93 template <typename RecordT>
94 class CatalogT {
95  typedef std::vector<PTR(RecordT)> Internal;
96 public:
97 
98  typedef RecordT Record;
99  typedef typename Record::Table Table;
100  typedef typename Record::ColumnView ColumnView;
101 
102  typedef RecordT value_type;
103  typedef RecordT & reference;
104  typedef PTR(RecordT) pointer;
105  typedef typename Internal::size_type size_type;
109 
111  PTR(Table) getTable() const { return _table; }
112 
114  Schema getSchema() const { return _table->getSchema(); }
115 
122  explicit CatalogT(PTR(Table) const & table = PTR(Table)()) : _table(table), _internal() {}
123 
125  explicit CatalogT(Schema const & schema) : _table(Table::make(schema)), _internal() {}
126 
137  template <typename InputIterator>
138  CatalogT(PTR(Table) const & table, InputIterator first, InputIterator last, bool deep=false) :
139  _table(table), _internal()
140  {
141  insert(end(), first, last, deep);
142  }
143 
145  CatalogT(CatalogT const & other) : _table(other._table), _internal(other._internal) {}
146 
153  template <typename OtherRecordT>
155  _table(other.getTable()), _internal(other.begin().base(), other.end().base())
156  {}
157 
159  CatalogT & operator=(CatalogT const & other) {
160  if (&other != this) {
161  _table = other._table;
162  _internal = other._internal;
163  }
164  return *this;
165  }
166 
173  if (size_type(mask.size()) != size()) {
174  throw LSST_EXCEPT(
175  pex::exceptions::LengthError,
176  (boost::format("Mask array with %d elements applied to catalog with %d elements")
177  % mask.size() % size()).str()
178  );
179  }
180  CatalogT<RecordT> result(getTable());
182  const_iterator catIter = begin();
183  for (; maskIter != mask.end(); ++maskIter, ++catIter) {
184  if (*maskIter) result.push_back(catIter);
185  }
186  return result;
187  }
188 
193  CatalogT<RecordT> subset(std::ptrdiff_t startd, std::ptrdiff_t stopd, std::ptrdiff_t step) const {
194  /* Python's slicing syntax is weird and wonderful.
195 
196  Both the "start" and "stop" indices can be negative, which means the
197  abs() of the index less than the size; [-1] means the last item.
198  Moreover, it's possible to have a negative index less than -len(); it
199  will get clipped. That is in fact one way to slice *backward* through
200  the array *and* include element 0;
201 
202  >>> range(10)[5:-20:-1]
203  [5, 4, 3, 2, 1, 0]
204 
205  The clipping tests in this function look more complicated than they
206  need to be, but that is partly because there are some weird edge cases.
207 
208  Also, ptrdiff_t vs size_t introduces some annoying complexity. Note
209  that the args are "startd"/"stopd" (not "start"/"stop").
210 
211  There is a fairly complete set of tests in tests/ticket2026.py; if you
212  try to simplify this function, be sure they continue to pass.
213  */
214  size_type S = size();
215  size_type start, stop = 0;
216  // Python doesn't allow step == 0
217  if (step == 0) {
218  throw LSST_EXCEPT(
219  pex::exceptions::InvalidParameterError,
220  "Step cannot be zero"
221  );
222  }
223  // Basic negative indexing rule: first add size
224  if (startd < 0) {
225  startd += S;
226  }
227  if (stopd < 0) {
228  stopd += S;
229  }
230  // Start gets clipped to zero; stop does not (yet).
231  if (startd < 0) {
232  startd = 0;
233  }
234  // Now start is non-negative, so can cast to size_t.
235  start = (size_type)startd;
236  if (start > S) {
237  start = S;
238  }
239  if (step > 0) {
240  // When stepping forward, stop gets clipped at zero,
241  // so is non-negative and can get cast to size_t.
242  if (stopd < 0) {
243  stopd = 0;
244  }
245  stop = (size_type)stopd;
246  if (stop > S) {
247  stop = S;
248  }
249  } else if (step < 0) {
250  // When stepping backward, stop gets clipped at -1 so that slices
251  // including 0 are possible.
252  if (stopd < 0) {
253  stopd = -1;
254  }
255  }
256 
257  if (((step > 0) && (start >= stop)) ||
258  ((step < 0) && ((std::ptrdiff_t)start <= stopd))) {
259  // Empty range
260  return CatalogT<RecordT>(getTable(), begin(), begin());
261  }
262 
263  if (step == 1) {
264  // Use the iterator-based constructor for this simple case
265  assert(start >= 0);
266  assert(stop > 0);
267  assert(start < S);
268  assert(stop <= S);
269  return CatalogT<RecordT>(getTable(), begin()+start, begin()+stop);
270  }
271 
272  // Build a new CatalogT and copy records into it.
274  size_type N = 0;
275  if (step >= 0) {
276  N = (stop - start) / step + (((stop - start) % step) ? 1 : 0);
277  } else {
278  N = (size_t)((stopd - (std::ptrdiff_t)start) / step +
279  (((stopd - (std::ptrdiff_t)start) % step) ? 1 : 0));
280  }
281  cat.reserve(N);
282  if (step >= 0) {
283  for (size_type i=start; i<stop; i+=step) {
284  cat.push_back(get(i));
285  }
286  } else {
287  for (std::ptrdiff_t i=(std::ptrdiff_t)start; i>stopd; i+=step) {
288  cat.push_back(get(i));
289  }
290  }
291  return cat;
292  }
293 
302  void writeFits(std::string const & filename, std::string const & mode="w", int flags=0) const {
303  io::FitsWriter::apply(filename, mode, *this, flags);
304  }
305 
314  void writeFits(fits::MemFileManager & manager, std::string const & mode="w", int flags=0) const {
315  io::FitsWriter::apply(manager, mode, *this, flags);
316  }
317 
325  void writeFits(fits::Fits & fitsfile, int flags=0) const {
326  io::FitsWriter::apply(fitsfile, *this, flags);
327  }
328 
338  static CatalogT readFits(std::string const & filename, int hdu=0, int flags=0) {
339  return io::FitsReader::apply<CatalogT>(filename, hdu, flags);
340  }
341 
351  static CatalogT readFits(fits::MemFileManager & manager, int hdu=0, int flags=0) {
352  return io::FitsReader::apply<CatalogT>(manager, hdu, flags);
353  }
354 
362  static CatalogT readFits(fits::Fits & fitsfile, int flags=0) {
363  return io::FitsReader::apply<CatalogT>(fitsfile, flags);
364  }
365 
372  if (boost::is_const<RecordT>::value) {
373  throw LSST_EXCEPT(
374  pex::exceptions::LogicError,
375  "Cannot get a column view from a CatalogT<RecordT const> (as column views are always "
376  "non-const views)."
377  );
378  }
379  return ColumnView::make(_table, begin(), end());
380  }
381 
383  bool isContiguous() const { return ColumnView::isRangeContiguous(_table, begin(), end()); }
384 
386 
391  iterator begin() { return iterator(_internal.begin()); }
392  iterator end() { return iterator(_internal.end()); }
393  const_iterator begin() const { return const_iterator(_internal.begin()); }
394  const_iterator end() const { return const_iterator(_internal.end()); }
396 
398  bool empty() const { return _internal.empty(); }
399 
401  size_type size() const { return _internal.size(); }
402 
404  size_type max_size() const { return _internal.max_size(); }
405 
413  size_type capacity() const { return _internal.size() + _table->getBufferSize(); }
414 
421  void reserve(size_type n) {
422  if (n <= _internal.size()) return;
423  _table->preallocate(n - _internal.size());
424  }
425 
427  reference operator[](size_type i) const { return *_internal[i]; }
428 
430  reference at(size_type i) const { return *_internal.at(i); }
431 
433  reference front() const { return *_internal.front(); }
434 
436  reference back() const { return *_internal.back(); }
437 
439  PTR(RecordT) const get(size_type i) const { return _internal[i]; }
440 
442  void set(size_type i, PTR(RecordT) const & p) {
443  _internal[i] = p;
444  }
445 
451  template <typename InputIterator>
452  void assign(InputIterator first, InputIterator last, bool deep=false) {
453  clear();
454  insert(end(), first, last, deep);
455  }
456 
458  void push_back(Record const & r) {
459  PTR(RecordT) p = _table->copyRecord(r);
460  _internal.push_back(p);
461  }
462 
464  void push_back(PTR(RecordT) const & p) {
465  _internal.push_back(p);
466  }
467 
469  PTR(RecordT) addNew() {
470  PTR(RecordT) r = _table->makeRecord();
471  _internal.push_back(r);
472  return r;
473  }
474 
476  void pop_back() { _internal.pop_back(); }
477 
479  CatalogT copy() const { return CatalogT(getTable()->clone(), begin(), end(), true); }
480 
496  template <typename InputIterator>
497  void insert(iterator pos, InputIterator first, InputIterator last, bool deep=false) {
499  pos, first, last, deep, (typename std::iterator_traits<InputIterator>::iterator_category*)0
500  );
501  if (deep) {
502  while (first != last) {
503  pos = insert(pos, *first);
504  ++pos;
505  ++first;
506  }
507  } else {
508  while (first != last) {
509  pos = insert(pos, first);
510  assert(pos != end());
511  ++pos;
512  ++first;
513  }
514  }
515  }
516 
518  template <typename InputIterator>
519  void insert(SchemaMapper const & mapper, iterator pos, InputIterator first, InputIterator last) {
520  if (!_table->getSchema().contains(mapper.getOutputSchema())) {
521  throw LSST_EXCEPT(
522  pex::exceptions::InvalidParameterError,
523  "SchemaMapper's output schema does not match catalog's schema"
524  );
525  }
527  pos, first, last, true, (typename std::iterator_traits<InputIterator>::iterator_category*)0
528  );
529  while (first != last) {
530  pos = insert(pos, _table->copyRecord(*first, mapper));
531  ++pos;
532  ++first;
533  }
534  }
535 
537  iterator insert(iterator pos, Record const & r) {
538  PTR(RecordT) p = _table->copyRecord(r);
539  return iterator(_internal.insert(pos.base(), p));
540  }
541 
543  iterator insert(iterator pos, PTR(RecordT) const & p) {
544  return iterator(_internal.insert(pos.base(), p));
545  }
546 
548  iterator erase(iterator pos) { return iterator(_internal.erase(pos.base())); }
549 
552  return iterator(_internal.erase(first.base(), last.base()));
553  }
554 
556  void swap(CatalogT & other) {
557  _table.swap(other._table);
558  _internal.swap(other._internal);
559  }
560 
562  void clear() { _internal.clear(); }
563 
565  template <typename T>
566  bool isSorted(Key<T> const & key) const;
567 
573  template <typename Compare>
574  bool isSorted(Compare cmp) const;
575 
577  template <typename T>
578  void sort(Key<T> const & key);
579 
585  template <typename Compare>
586  void sort(Compare cmp);
587 
589 
603  template <typename T>
604  iterator find(typename Field<T>::Value const & value, Key<T> const & key);
605 
606  template <typename T>
607  const_iterator find(typename Field<T>::Value const & value, Key<T> const & key) const;
609 
611 
624  template <typename T>
625  iterator lower_bound(typename Field<T>::Value const & value, Key<T> const & key);
626 
627  template <typename T>
628  const_iterator lower_bound(typename Field<T>::Value const & value, Key<T> const & key) const;
629 
630  template <typename T>
631  iterator upper_bound(typename Field<T>::Value const & value, Key<T> const & key);
632 
633  template <typename T>
634  const_iterator upper_bound(typename Field<T>::Value const & value, Key<T> const & key) const;
635 
636  template <typename T>
637  std::pair<iterator,iterator>
638  equal_range(typename Field<T>::Value const & value, Key<T> const & key);
639 
640  template <typename T>
641  std::pair<const_iterator,const_iterator>
642  equal_range(typename Field<T>::Value const & value, Key<T> const & key) const;
644 
646 
659  Internal const & getInternal() const { return _internal; }
661 
662 private:
663 
664  template <typename InputIterator>
666  iterator & pos, InputIterator first, InputIterator last, bool deep,
667  std::random_access_iterator_tag *
668  ) {
669  if (deep) _table->preallocate(last - first);
670  }
671 
672  template <typename InputIterator>
674  iterator pos, InputIterator first, InputIterator last, bool deep,
675  std::input_iterator_tag *
676  ) {}
677 
680 };
681 
682 namespace detail {
683 
684 template <typename RecordT, typename T>
686 
687  bool operator()(RecordT const & a, RecordT const & b) const { return a.get(key) < b.get(key); }
688 
690 };
691 
692 template <typename RecordT, typename Adaptee>
694 
695  bool operator()(PTR(RecordT) const & a, PTR(RecordT) const & b) const {
696  return adaptee(*a, *b);
697  }
698 
699  Adaptee adaptee;
700 };
701 
702 template <typename RecordT, typename T>
704 
705  typedef typename Field<T>::Value result_type;
706 
707  result_type operator()(RecordT const & r) const { return r.get(key); }
708 
710 };
711 
712 } // namespace detail
713 
714 template <typename RecordT>
715 template <typename Compare>
716 bool CatalogT<RecordT>::isSorted(Compare cmp) const {
719  if (empty()) return true;
720  const_iterator last = this->begin();
721  const_iterator i = last; ++i;
722  for (; i != this->end(); ++i) {
723  if (f(i, last)) return false;
724  last = i;
725  }
726  return true;
727 }
728 
729 template <typename RecordT>
730 template <typename Compare>
731 void CatalogT<RecordT>::sort(Compare cmp) {
733  std::stable_sort(_internal.begin(), _internal.end(), f);
734 }
735 
736 template <typename RecordT>
737 template <typename T>
738 bool CatalogT<RecordT>::isSorted(Key<T> const & key) const {
740  return isSorted(f);
741 }
742 
743 template <typename RecordT>
744 template <typename T>
745 void CatalogT<RecordT>::sort(Key<T> const & key) {
747  return sort(f);
748 }
749 
750 template <typename RecordT>
751 template <typename T>
753 CatalogT<RecordT>::find(typename Field<T>::Value const & value, Key<T> const & key) {
755  // Iterator adaptor that makes a CatalogT iterator work like an iterator over field values.
756  typedef boost::transform_iterator<detail::KeyExtractionFunctor<RecordT,T>,iterator> SearchIter;
757  // Use binary search for log n search; requires sorted table.
758  SearchIter i = std::lower_bound(SearchIter(begin(), f), SearchIter(end(), f), value);
759  if (i.base() == end() || *i != value) return end();
760  return i.base();
761 }
762 
763 template <typename RecordT>
764 template <typename T>
766 CatalogT<RecordT>::find(typename Field<T>::Value const & value, Key<T> const & key) const {
768  // Iterator adaptor that makes a CatalogT iterator work like an iterator over field values.
769  typedef boost::transform_iterator<detail::KeyExtractionFunctor<RecordT,T>,const_iterator> SearchIter;
770  // Use binary search for log n search; requires sorted table.
771  SearchIter i = std::lower_bound(SearchIter(begin(), f), SearchIter(end(), f), value);
772  if (i.base() == end() || *i != value) return end();
773  return i.base();
774 }
775 
776 template <typename RecordT>
777 template <typename T>
779 CatalogT<RecordT>::lower_bound(typename Field<T>::Value const & value, Key<T> const & key) {
781  // Iterator adaptor that makes a CatalogT iterator work like an iterator over field values.
782  typedef boost::transform_iterator<detail::KeyExtractionFunctor<RecordT,T>,iterator> SearchIter;
783  SearchIter i = std::lower_bound(SearchIter(begin(), f), SearchIter(end(), f), value);
784  return i.base();
785 }
786 
787 template <typename RecordT>
788 template <typename T>
790 CatalogT<RecordT>::lower_bound(typename Field<T>::Value const & value, Key<T> const & key) const {
792  // Iterator adaptor that makes a CatalogT iterator work like an iterator over field values.
793  typedef boost::transform_iterator<detail::KeyExtractionFunctor<RecordT,T>,const_iterator> SearchIter;
794  SearchIter i = std::lower_bound(SearchIter(begin(), f), SearchIter(end(), f), value);
795  return i.base();
796 }
797 
798 template <typename RecordT>
799 template <typename T>
801 CatalogT<RecordT>::upper_bound(typename Field<T>::Value const & value, Key<T> const & key) {
803  // Iterator adaptor that makes a CatalogT iterator work like an iterator over field values.
804  typedef boost::transform_iterator<detail::KeyExtractionFunctor<RecordT,T>,iterator> SearchIter;
805  SearchIter i = std::upper_bound(SearchIter(begin(), f), SearchIter(end(), f), value);
806  return i.base();
807 }
808 
809 template <typename RecordT>
810 template <typename T>
812 CatalogT<RecordT>::upper_bound(typename Field<T>::Value const & value, Key<T> const & key) const {
814  // Iterator adaptor that makes a CatalogT iterator work like an iterator over field values.
815  typedef boost::transform_iterator<detail::KeyExtractionFunctor<RecordT,T>,const_iterator> SearchIter;
816  SearchIter i = std::upper_bound(SearchIter(begin(), f), SearchIter(end(), f), value);
817  return i.base();
818 }
819 
820 template <typename RecordT>
821 template <typename T>
822 std::pair<typename CatalogT<RecordT>::iterator,typename CatalogT<RecordT>::iterator>
823 CatalogT<RecordT>::equal_range(typename Field<T>::Value const & value, Key<T> const & key) {
825  // Iterator adaptor that makes a CatalogT iterator work like an iterator over field values.
826  typedef boost::transform_iterator<detail::KeyExtractionFunctor<RecordT,T>,iterator> SearchIter;
827  std::pair<SearchIter,SearchIter> i
828  = std::equal_range(SearchIter(begin(), f), SearchIter(end(), f), value);
829  return std::make_pair(i.first.base(), i.second.base());
830 
831 }
832 
833 template <typename RecordT>
834 template <typename T>
835 std::pair<typename CatalogT<RecordT>::const_iterator,typename CatalogT<RecordT>::const_iterator>
836 CatalogT<RecordT>::equal_range(typename Field<T>::Value const & value, Key<T> const & key) const {
838  // Iterator adaptor that makes a CatalogT iterator work like an iterator over field values.
839  typedef boost::transform_iterator<detail::KeyExtractionFunctor<RecordT,T>,const_iterator> SearchIter;
840  std::pair<SearchIter,SearchIter> i
841  = std::equal_range(SearchIter(begin(), f), SearchIter(end(), f), value);
842  return std::make_pair(i.first.base(), i.second.base());
843 }
844 
846 
867 template <typename RecordT, typename Catalog, typename T>
868 PTR(RecordT) _Catalog_find(Catalog const & catalog, T const & value, Key<T> const & key) {
869  typename Catalog::const_iterator iter = catalog.find(value, key);
870  if (iter == catalog.end()) {
871  return PTR(RecordT)();
872  }
873  return iter; // n.b. CatalogIterator is explicitly convertible to shared_ptr
874 }
875 
876 template <typename Catalog, typename T>
877 int _Catalog_lower_bound(Catalog const & catalog, T const & value, Key<T> const & key) {
878  return catalog.lower_bound(value, key) - catalog.begin();
879 }
880 
881 template <typename Catalog, typename T>
882 int _Catalog_upper_bound(Catalog const & catalog, T const & value, Key<T> const & key) {
883  return catalog.upper_bound(value, key) - catalog.begin();
884 }
885 
886 template <typename Catalog, typename T>
887 std::pair<int,int> _Catalog_equal_range(Catalog const & catalog, T const & value, Key<T> const & key) {
888  std::pair<typename Catalog::const_iterator,typename Catalog::const_iterator> p
889  = catalog.equal_range(value, key);
890  return std::pair<int,int>(p.first - catalog.begin(), p.second - catalog.begin());
891 }
892 
894 
895 
896 }}} // namespace lsst::afw::table
897 
898 #endif // !AFW_TABLE_Catalog_h_INCLUDED
int iter
CatalogT & operator=(CatalogT const &other)
Shallow assigment.
Definition: Catalog.h:159
Defines the fields and offsets for a table.
Definition: Schema.h:46
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...
Definition: Catalog.h:172
void _maybeReserve(iterator &pos, InputIterator first, InputIterator last, bool deep, std::random_access_iterator_tag *)
Definition: Catalog.h:665
static CatalogT readFits(fits::MemFileManager &manager, int hdu=0, int flags=0)
Read a FITS binary table from a RAM file.
Definition: Catalog.h:351
void push_back(Record const &r)
Add a copy of the given record to the end of the catalog.
Definition: Catalog.h:458
bool isSorted(Key< T > const &key) const
Return true if the catalog is in ascending order according to the given key.
Definition: Catalog.h:738
#define PTR(...)
Definition: base.h:41
BaseT::value_type::element_type & dereference() const
Definition: Catalog.h:59
iterator erase(iterator pos)
Erase the record pointed to by pos, and return an iterator the next record.
Definition: Catalog.h:548
CatalogT copy() const
Deep-copy the catalog using a cloned table.
Definition: Catalog.h:479
CatalogT(boost::shared_ptr< Table > const &table, InputIterator first, InputIterator last, bool deep=false)
Construct a catalog from a table and an iterator range.
Definition: Catalog.h:138
void reserve(size_type n)
Increase the capacity of the catalog to the given size.
Definition: Catalog.h:421
bool isContiguous() const
Return true if all records are contiguous.
Definition: Catalog.h:383
Schema const getOutputSchema() const
Return the output schema (copy-on-write).
Definition: SchemaMapper.h:26
A custom container class for records, based on std::vector.
Definition: Catalog.h:94
void sort(Key< T > const &key)
Sort the catalog in-place by the field with the given key.
Definition: Catalog.h:745
A mapping between the keys of two Schemas, used to copy data between them.
Definition: SchemaMapper.h:19
static void apply(OutputT &output, std::string const &mode, ContainerT const &container, int flags)
Driver for writing FITS files.
Definition: FitsWriter.h:35
Internal & getInternal()
Return a reference to the internal vector-of-shared_ptr.
Definition: Catalog.h:658
iterator erase(iterator first, iterator last)
Erase the records in the range [first, last).
Definition: Catalog.h:551
result_type operator()(RecordT const &r) const
Definition: Catalog.h:707
boost::shared_ptr< Table > _table
Definition: Catalog.h:678
boost::shared_ptr< Table > getTable() const
Return the table associated with the catalog.
Definition: Catalog.h:111
void writeFits(std::string const &filename, std::string const &mode="w", int flags=0) const
Write a FITS binary table to a regular file.
Definition: Catalog.h:302
std::pair< int, int > _Catalog_equal_range(Catalog const &catalog, T const &value, Key< T > const &key)
Definition: Catalog.h:887
Record::Table Table
Definition: Catalog.h:99
size_type max_size() const
Return the maximum number of elements allowed in a catalog.
Definition: Catalog.h:404
int _Catalog_lower_bound(Catalog const &catalog, T const &value, Key< T > const &key)
Definition: Catalog.h:877
CatalogT(CatalogT< OtherRecordT > const &other)
Shallow copy constructor from a container containing a related record type.
Definition: Catalog.h:154
void push_back(boost::shared_ptr< RecordT > const &p)
Add the given record to the end of the catalog without copying.
Definition: Catalog.h:464
A simple struct that combines the two arguments that must be passed to most cfitsio routines and cont...
Definition: fits.h:194
void swap(CatalogT &other)
Shallow swap of two catalogs.
Definition: Catalog.h:556
boost::shared_ptr< RecordT > const get(size_type i) const
Return a pointer to the record at index i.
Definition: Catalog.h:439
CatalogIterator(BaseT const &base)
Definition: Catalog.h:46
boost::shared_ptr< RecordT > addNew()
Create a new record, add it to the end of the catalog, and return a pointer to it.
Definition: Catalog.h:469
void writeFits(fits::MemFileManager &manager, std::string const &mode="w", int flags=0) const
Write a FITS binary table to a RAM file.
Definition: Catalog.h:314
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.
Definition: Catalog.h:519
iterator upper_bound(typename Field< T >::Value const &value, Key< T > const &key)
Performed binary searches on sorted fields.
void clear()
Remove all records from the catalog.
Definition: Catalog.h:562
const_iterator end() const
Definition: Catalog.h:394
CatalogT(Schema const &schema)
Construct a catalog from a schema, creating a table with Table::make(schema).
Definition: Catalog.h:125
int _Catalog_upper_bound(Catalog const &catalog, T const &value, Key< T > const &key)
Definition: Catalog.h:882
iterator lower_bound(typename Field< T >::Value const &value, Key< T > const &key)
Performed binary searches on sorted fields.
CatalogIterator< typename Internal::const_iterator > const_iterator
Definition: Catalog.h:108
std::vector< boost::shared_ptr< RecordT > > Internal
Definition: Catalog.h:95
Schema getSchema() const
Return the schema associated with the catalog&#39;s table.
Definition: Catalog.h:114
Lifetime-management for memory that goes into FITS memory files.
Definition: fits.h:106
Iterator class for CatalogT.
Definition: Catalog.h:34
size_type size() const
Return the size of the first dimension.
void pop_back()
Remove the last record in the catalog.
Definition: Catalog.h:476
reference back() const
Return the last record.
Definition: Catalog.h:436
Internal::difference_type difference_type
Definition: Catalog.h:106
T Value
the type returned by BaseRecord::get
Definition: FieldBase.h:50
void assign(InputIterator first, InputIterator last, bool deep=false)
Replace the contents of the table with an iterator range.
Definition: Catalog.h:452
const_iterator begin() const
Definition: Catalog.h:393
boost::shared_ptr< RecordT > _Catalog_find(Catalog const &catalog, T const &value, Key< T > const &key)
Definition: Catalog.h:868
void set(size_type i, boost::shared_ptr< RecordT > const &p)
Set the record at index i to a pointer.
Definition: Catalog.h:442
tbl::Schema schema
iterator insert(iterator pos, boost::shared_ptr< RecordT > const &p)
Insert the given record at the given position without copying.
Definition: Catalog.h:543
bool operator()(RecordT const &a, RecordT const &b) const
Definition: Catalog.h:687
boost::shared_ptr< PeakRecord > pointer
Definition: Catalog.h:104
#define LSST_EXCEPT(type,...)
Definition: Exception.h:46
void _maybeReserve(iterator pos, InputIterator first, InputIterator last, bool deep, std::input_iterator_tag *)
Definition: Catalog.h:673
A multidimensional strided array.
Definition: Array.h:47
ColumnView getColumnView() const
Return a ColumnView of this catalog&#39;s records.
Definition: Catalog.h:371
A class used as a handle to a particular field in a table.
Definition: fwd.h:44
Iterator end() const
Return an Iterator to one past the end of the array.
Definition: ArrayBase.h:108
reference at(size_type i) const
Return the record at index i (throws std::out_of_range).
Definition: Catalog.h:430
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. The arguments correspond to python&#39;s slice() synt...
Definition: Catalog.h:193
bool operator()(boost::shared_ptr< RecordT > const &a, boost::shared_ptr< RecordT > const &b) const
Definition: Catalog.h:695
static CatalogT readFits(fits::Fits &fitsfile, int flags=0)
Read a FITS binary table from a file object already at the correct extension.
Definition: Catalog.h:362
CatalogT(CatalogT const &other)
Shallow copy constructor.
Definition: Catalog.h:145
afw::table::Key< double > b
std::pair< iterator, iterator > equal_range(typename Field< T >::Value const &value, Key< T > const &key)
Performed binary searches on sorted fields.
Record::ColumnView ColumnView
Definition: Catalog.h:100
CatalogT(boost::shared_ptr< Table > const &table=boost::shared_ptr< Table >())
Construct a catalog from a table (or nothing).
Definition: Catalog.h:122
CatalogIterator & operator=(boost::shared_ptr< RecordT > const &other) const
Definition: Catalog.h:52
ExpressionTraits< Derived >::Iterator Iterator
Nested expression or element iterator.
reference operator[](size_type i) const
Return the record at index i.
Definition: Catalog.h:427
size_type capacity() const
Return the capacity of the catalog.
Definition: Catalog.h:413
iterator insert(iterator pos, Record const &r)
Insert a copy of the given record at the given position.
Definition: Catalog.h:537
void writeFits(fits::Fits &fitsfile, int flags=0) const
Write a FITS binary table to an open file object.
Definition: Catalog.h:325
Internal const & getInternal() const
Return a reference to the internal vector-of-shared_ptr.
Definition: Catalog.h:659
void insert(iterator pos, InputIterator first, InputIterator last, bool deep=false)
Insert an iterator range into the table.
Definition: Catalog.h:497
reference front() const
Return the first record.
Definition: Catalog.h:433
static CatalogT readFits(std::string const &filename, int hdu=0, int flags=0)
Read a FITS binary table from a regular file.
Definition: Catalog.h:338
Include files required for standard LSST Exception handling.
iterator find(typename Field< T >::Value const &value, Key< T > const &key)
Return an iterator to the record with the given value.
bool empty() const
Return true if the catalog has no records.
Definition: Catalog.h:398
CatalogIterator(CatalogIterator< OtherBaseT > const &other)
Definition: Catalog.h:42
size_type size() const
Return the number of elements in the catalog.
Definition: Catalog.h:401
CatalogIterator< typename Internal::iterator > iterator
Definition: Catalog.h:107
friend class boost::iterator_core_access
Definition: Catalog.h:58
Iterator begin() const
Return an Iterator to the beginning of the array.
Definition: ArrayBase.h:99