LSST Applications  21.0.0-147-g0e635eb1+1acddb5be5,22.0.0+052faf71bd,22.0.0+1ea9a8b2b2,22.0.0+6312710a6c,22.0.0+729191ecac,22.0.0+7589c3a021,22.0.0+9f079a9461,22.0.1-1-g7d6de66+b8044ec9de,22.0.1-1-g87000a6+536b1ee016,22.0.1-1-g8e32f31+6312710a6c,22.0.1-10-gd060f87+016f7cdc03,22.0.1-12-g9c3108e+df145f6f68,22.0.1-16-g314fa6d+c825727ab8,22.0.1-19-g93a5c75+d23f2fb6d8,22.0.1-19-gb93eaa13+aab3ef7709,22.0.1-2-g8ef0a89+b8044ec9de,22.0.1-2-g92698f7+9f079a9461,22.0.1-2-ga9b0f51+052faf71bd,22.0.1-2-gac51dbf+052faf71bd,22.0.1-2-gb66926d+6312710a6c,22.0.1-2-gcb770ba+09e3807989,22.0.1-20-g32debb5+b8044ec9de,22.0.1-23-gc2439a9a+fb0756638e,22.0.1-3-g496fd5d+09117f784f,22.0.1-3-g59f966b+1e6ba2c031,22.0.1-3-g849a1b8+f8b568069f,22.0.1-3-gaaec9c0+c5c846a8b1,22.0.1-32-g5ddfab5d3+60ce4897b0,22.0.1-4-g037fbe1+64e601228d,22.0.1-4-g8623105+b8044ec9de,22.0.1-5-g096abc9+d18c45d440,22.0.1-5-g15c806e+57f5c03693,22.0.1-7-gba73697+57f5c03693,master-g6e05de7fdc+c1283a92b8,master-g72cdda8301+729191ecac,w.2021.39
LSST Data Management Base Package
Simple.h
Go to the documentation of this file.
1 // -*- lsst-c++ -*-
2 /*
3  * LSST Data Management System
4  * Copyright 2008, 2009, 2010, 2011 LSST Corporation.
5  *
6  * This product includes software developed by the
7  * LSST Project (http://www.lsst.org/).
8  *
9  * This program is free software: you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation, either version 3 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the LSST License Statement and
20  * the GNU General Public License along with this program. If not,
21  * see <http://www.lsstcorp.org/LegalNotices/>.
22  */
23 #ifndef AFW_TABLE_Simple_h_INCLUDED
24 #define AFW_TABLE_Simple_h_INCLUDED
25 
29 #include "lsst/afw/table/Catalog.h"
33 
34 namespace lsst {
35 namespace afw {
36 namespace table {
37 
38 class SimpleRecord;
39 class SimpleTable;
40 
48 class SimpleRecord : public BaseRecord {
49 public:
50  using Table = SimpleTable;
54 
65  BaseRecord(token, std::move(data))
66  {}
67 
69  return std::static_pointer_cast<SimpleTable const>(BaseRecord::getTable());
70  }
71 
73  RecordId getId() const;
75  void setId(RecordId id);
76 
78  void setCoord(lsst::geom::SpherePoint const& coord);
79 
80  lsst::geom::Angle getRa() const;
81  void setRa(lsst::geom::Angle ra);
82 
83  lsst::geom::Angle getDec() const;
86 
87  SimpleRecord(const SimpleRecord&) = delete;
88  SimpleRecord& operator=(const SimpleRecord&) = delete;
91  ~SimpleRecord() override;
92 
93 private:
94  friend class SimpleTable;
95 };
96 
102 class SimpleTable : public BaseTable {
103 public:
108 
120  std::shared_ptr<IdFactory> const& idFactory);
121 
130  return make(schema, IdFactory::makeSimple());
131  }
132 
141  Schema r = getMinimalSchema().schema;
142  r.disconnectAliases();
143  return r;
144  }
145 
152  static bool checkSchema(Schema const& other) { return other.contains(getMinimalSchema().schema); }
153 
155  std::shared_ptr<IdFactory> getIdFactory() { return _idFactory; }
156 
158  std::shared_ptr<IdFactory const> getIdFactory() const { return _idFactory; }
159 
161  void setIdFactory(std::shared_ptr<IdFactory> f) { _idFactory = f; }
162 
164 
170  static Key<RecordId> getIdKey() { return getMinimalSchema().id; }
172  static CoordKey getCoordKey() { return getMinimalSchema().coord; }
174 
176  std::shared_ptr<SimpleTable> clone() const { return std::static_pointer_cast<SimpleTable>(_clone()); }
177 
180  return std::static_pointer_cast<SimpleRecord>(_makeRecord());
181  }
182 
185  return std::static_pointer_cast<SimpleRecord>(BaseTable::copyRecord(other));
186  }
187 
190  return std::static_pointer_cast<SimpleRecord>(BaseTable::copyRecord(other, mapper));
191  }
192 
193  SimpleTable& operator=(SimpleTable const&) = delete;
195  ~SimpleTable() override;
196 
197 protected:
198  SimpleTable(Schema const& schema, std::shared_ptr<IdFactory> const& idFactory);
199 
200  explicit SimpleTable(SimpleTable const& other);
201  explicit SimpleTable(SimpleTable&& other);
202 
203  std::shared_ptr<BaseTable> _clone() const override;
204 
206 
207 private:
208  // Struct that holds the minimal schema and the special keys we've added to it.
209  struct MinimalSchema {
210  Schema schema;
212  CoordKey coord;
213 
214  MinimalSchema();
215  };
216 
217  // Return the singleton minimal schema.
218  static MinimalSchema& getMinimalSchema();
219 
220  friend class io::FitsWriter;
221 
222  // Return a writer object that knows how to save in FITS format. See also FitsWriter.
223  std::shared_ptr<io::FitsWriter> makeFitsWriter(fits::Fits* fitsfile, int flags) const override;
224 
225  std::shared_ptr<IdFactory> _idFactory; // generates IDs for new records
226 };
227 
230 
233  set(SimpleTable::getCoordKey(), coord);
234 }
235 
238 
241 } // namespace table
242 } // namespace afw
243 } // namespace lsst
244 
245 #endif // !AFW_TABLE_Simple_h_INCLUDED
char * data
Definition: BaseRecord.cc:61
table::Key< int > id
Definition: Detector.cc:162
double dec
Definition: Match.cc:41
SchemaMapper * mapper
Definition: SchemaMapper.cc:71
table::Schema schema
Definition: python.h:134
A simple struct that combines the two arguments that must be passed to most cfitsio routines and cont...
Definition: fits.h:297
Column-wise view into a sequence of records that have been allocated contiguously.
Base class for all records.
Definition: BaseRecord.h:31
void set(Key< T > const &key, U const &value)
Set value of a field for the given key.
Definition: BaseRecord.h:164
Field< T >::Value get(Key< T > const &key) const
Return the value of a field for the given key.
Definition: BaseRecord.h:151
std::shared_ptr< BaseTable const > getTable() const
Return the table this record is associated with.
Definition: BaseRecord.h:83
Base class for all tables.
Definition: BaseTable.h:61
std::shared_ptr< BaseRecord > copyRecord(BaseRecord const &input)
Deep-copy a record, requiring that it have the same schema as this table.
Definition: BaseTable.cc:128
A FunctorKey used to get or set celestial coordinates from a pair of lsst::geom::Angle keys.
Definition: aggregates.h:210
static std::shared_ptr< IdFactory > makeSimple()
Return a simple IdFactory that simply counts from 1.
Definition: IdFactory.cc:70
A class used as a handle to a particular field in a table.
Definition: Key.h:53
Defines the fields and offsets for a table.
Definition: Schema.h:51
void disconnectAliases()
Sever the connection between this schema and any others with which it shares aliases.
Definition: Schema.cc:540
int contains(Schema const &other, int flags=EQUAL_KEYS) const
Test whether the given schema is a subset of this.
Definition: Schema.cc:490
A mapping between the keys of two Schemas, used to copy data between them.
Definition: SchemaMapper.h:21
Record class that must contain a unique ID field and a celestial coordinate field.
Definition: Simple.h:48
lsst::geom::Angle getRa() const
Definition: Simple.h:236
void setCoord(lsst::geom::SpherePoint const &coord)
Definition: Simple.h:232
std::shared_ptr< SimpleTable const > getTable() const
Definition: Simple.h:68
SimpleRecord(SimpleRecord &&)=delete
RecordId getId() const
Convenience accessors for the keys in the minimal reference schema.
Definition: Simple.h:228
lsst::geom::SpherePoint getCoord() const
Definition: Simple.h:231
SimpleRecord(const SimpleRecord &)=delete
void setId(RecordId id)
Definition: Simple.h:229
void setRa(lsst::geom::Angle ra)
Definition: Simple.h:237
void setDec(lsst::geom::Angle dec)
Definition: Simple.h:240
friend class SimpleTable
Definition: Simple.h:94
SimpleRecord(ConstructionToken const &token, detail::RecordData &&data)
Constructor used by SimpleTable.
Definition: Simple.h:64
SimpleRecord & operator=(const SimpleRecord &)=delete
SimpleRecord & operator=(SimpleRecord &&)=delete
lsst::geom::Angle getDec() const
Definition: Simple.h:239
Table class that must contain a unique ID field and a celestial coordinate field.
Definition: Simple.h:102
std::shared_ptr< SimpleRecord > makeRecord()
Default-construct an associated record.
Definition: Simple.h:179
static std::shared_ptr< SimpleTable > make(Schema const &schema)
Construct a new table.
Definition: Simple.h:129
SimpleTable & operator=(SimpleTable &&)=delete
std::shared_ptr< IdFactory > getIdFactory()
Return the object that generates IDs for the table (may be null).
Definition: Simple.h:155
static bool checkSchema(Schema const &other)
Return true if the given schema is a valid SimpleTable schema.
Definition: Simple.h:152
std::shared_ptr< BaseTable > _clone() const override
Clone implementation with noncovariant return types.
Definition: Simple.cc:108
static Schema makeMinimalSchema()
Return a minimal schema for Simple tables and records.
Definition: Simple.h:140
std::shared_ptr< IdFactory const > getIdFactory() const
Return the object that generates IDs for the table (may be null).
Definition: Simple.h:158
std::shared_ptr< SimpleRecord > copyRecord(BaseRecord const &other, SchemaMapper const &mapper)
Deep-copy a record, requiring that it have the same schema as this table.
Definition: Simple.h:189
std::shared_ptr< BaseRecord > _makeRecord() override
Default-construct an associated record (protected implementation).
Definition: Simple.cc:112
static CoordKey getCoordKey()
Key for the celestial coordinates.
Definition: Simple.h:172
void setIdFactory(std::shared_ptr< IdFactory > f)
Switch to a new IdFactory – object that generates IDs for the table (may be null).
Definition: Simple.h:161
static std::shared_ptr< SimpleTable > make(Schema const &schema, std::shared_ptr< IdFactory > const &idFactory)
Construct a new table.
Definition: Simple.cc:75
static Key< RecordId > getIdKey()
Get keys for standard fields shared by all references.
Definition: Simple.h:170
std::shared_ptr< SimpleTable > clone() const
Return a polymorphic deep copy of the table.
Definition: Simple.h:176
SimpleTable(Schema const &schema, std::shared_ptr< IdFactory > const &idFactory)
Definition: Simple.cc:84
std::shared_ptr< SimpleRecord > copyRecord(BaseRecord const &other)
Deep-copy a record, requiring that it have the same schema as this table.
Definition: Simple.h:184
SimpleTable & operator=(SimpleTable const &)=delete
Custom catalog class for record/table subclasses that are guaranteed to have an ID,...
Definition: SortedCatalog.h:42
Writer object for FITS binary tables.
Definition: FitsWriter.h:25
A class representing an angle.
Definition: Angle.h:127
Point in an unspecified spherical coordinate system.
Definition: SpherePoint.h:57
A base class for image defects.
STL namespace.
Helper struct that contains the information passed from BaseTable to BaseRecord at construction.
Definition: BaseTable.h:32