LSST Applications g05325017a3+be04ab5bc8,g2079a07aa2+3e9fd84d81,g20cdd03214+600de29eb2,g2305ad1205+5e1b0c67c7,g2bbee38e9b+69e041a28d,g337abbeb29+69e041a28d,g3a166c0a6a+69e041a28d,g4322eb9e3a+9670871960,g4e26c3aaff+9125fe5495,g50ff169b8f+96c6868917,g52b1c1532d+585e252eca,g591dd9f2cf+608c162c81,g5c3423f6d4+600de29eb2,g607f77f49a+600de29eb2,g69c4c69b53+69e041a28d,g858d7b2824+600de29eb2,g99cad8db69+a7f8c65a2d,g9ddcbc5298+9a081db1e4,ga1e77700b3+2cbb763275,ga8d6e2f9c9+7a336fa28a,gae0086650b+585e252eca,gb0e22166c9+0e73c8378f,gb7c702c636+aec2f3b930,gbb8dafda3b+7d1409958d,gc120e1dc64+acd995d0d8,gc28159a63d+69e041a28d,gcdd4ae20e8+5ef4c697da,gcf0d15dbbd+5ef4c697da,gd1535ee943+1ef0950dc9,gdaeeff99f8+f9a426f77a,gddc38dedce+585e252eca,ge79ae78c31+69e041a28d,gf905fbdb4b+471d9f2c03,gf907d663e3+01e3c6626b,gfbcc870c63+b310236976,w.2024.25
LSST Data Management Base Package
Loading...
Searching...
No Matches
BaseRecord.cc
Go to the documentation of this file.
1// -*- lsst-c++ -*-
2
3#include <iostream>
4
8
9namespace lsst {
10namespace afw {
11namespace table {
12
13namespace {
14
15// A Schema Functor used to set floating point-fields to NaN and initialize variable-length arrays
16// using placement new. All other fields are left alone, as they should already be zero.
17struct RecordInitializer {
18 template <typename T>
19 static void fill(T *element, std::size_t size) {} // this matches all non-floating-point-element fields.
20
21 static void fill(float *element, std::size_t size) {
23 }
24
25 static void fill(double *element, std::size_t size) {
27 }
28
29 static void fill(lsst::geom::Angle *element, std::size_t size) {
30 fill(reinterpret_cast<double *>(element), size);
31 }
32
33 template <typename T>
34 void operator()(SchemaItem<T> const &item) const {
35 fill(reinterpret_cast<typename Field<T>::Element *>(data + item.key.getOffset()),
36 item.key.getElementCount());
37 }
38
39 template <typename T>
40 void operator()(SchemaItem<Array<T> > const &item) const {
41 if (item.key.isVariableLength()) {
42 // Use placement new because the memory (for one ndarray) is already allocated
43 new (data + item.key.getOffset()) ndarray::Array<T, 1, 1>();
44 } else {
45 fill(reinterpret_cast<typename Field<T>::Element *>(data + item.key.getOffset()),
46 item.key.getElementCount());
47 }
48 }
49
50 void operator()(SchemaItem<std::string> const &item) const {
51 if (item.key.isVariableLength()) {
52 // Use placement new because the memory (for one std::string) is already allocated
53 new (reinterpret_cast<std::string *>(data + item.key.getOffset())) std::string();
54 } else {
55 fill(reinterpret_cast<char *>(data + item.key.getOffset()), item.key.getElementCount());
56 }
57 }
58
59 void operator()(SchemaItem<Flag> const &item) const {} // do nothing for Flag fields; already 0
60
61 char *data;
62};
63
64// A Schema::forEach and SchemaMapper::forEach functor that copies data from one record to another.
65struct CopyValue {
66 template <typename U>
67 void operator()(Key<U> const& inputKey, Key<U> const& outputKey) const {
68 typename Field<U>::Element const* inputElem = _inputRecord->getElement(inputKey);
69 std::copy(inputElem, inputElem + inputKey.getElementCount(), _outputRecord->getElement(outputKey));
70 }
71
72 template <typename U>
73 void operator()(Key<Array<U> > const& inputKey, Key<Array<U> > const& outputKey) const {
74 if (inputKey.isVariableLength() != outputKey.isVariableLength()) {
76 "At least one input array field is variable-length"
77 " and the correponding output is not, or vice-versa");
78 }
79 if (inputKey.isVariableLength()) {
80 ndarray::Array<U, 1, 1> value = ndarray::copy(_inputRecord->get(inputKey));
81 _outputRecord->set(outputKey, value);
82 return;
83 }
84 typename Field<U>::Element const* inputElem = _inputRecord->getElement(inputKey);
85 std::copy(inputElem, inputElem + inputKey.getElementCount(), _outputRecord->getElement(outputKey));
86 }
87
88 void operator()(Key<std::string> const& inputKey, Key<std::string> const& outputKey) const {
89 if (inputKey.isVariableLength() != outputKey.isVariableLength()) {
91 "At least one input string field is variable-length "
92 "and the correponding output is not, or vice-versa");
93 }
94 if (inputKey.isVariableLength()) {
95 std::string value = _inputRecord->get(inputKey);
96 _outputRecord->set(outputKey, value);
97 return;
98 }
99 char const* inputElem = _inputRecord->getElement(inputKey);
100 std::copy(inputElem, inputElem + inputKey.getElementCount(), _outputRecord->getElement(outputKey));
101 }
102
103 void operator()(Key<Flag> const& inputKey, Key<Flag> const& outputKey) const {
104 _outputRecord->set(outputKey, _inputRecord->get(inputKey));
105 }
106
107 template <typename U>
108 void operator()(SchemaItem<U> const& item) const {
109 (*this)(item.key, item.key);
110 }
111
112 CopyValue(BaseRecord const* inputRecord, BaseRecord* outputRecord)
113 : _inputRecord(inputRecord), _outputRecord(outputRecord) {}
114
115private:
116 BaseRecord const* _inputRecord;
117 BaseRecord* _outputRecord;
118};
119
120} // namespace
121
122void BaseRecord::assign(BaseRecord const& other) {
123 if (this->getSchema() != other.getSchema()) {
124 throw LSST_EXCEPT(lsst::pex::exceptions::LogicError, "Unequal schemas in record assignment.");
125 }
126 this->getSchema().forEach(CopyValue(&other, this));
127 this->_assign(other); // let derived classes assign their own stuff
128}
129
131 if (!other.getSchema().contains(mapper.getInputSchema())) {
133 "Unequal schemas between input record and mapper.");
134 }
135 if (!this->getSchema().contains(mapper.getOutputSchema())) {
137 "Unequal schemas between output record and mapper.");
138 }
139 mapper.forEach(CopyValue(&other, this)); // use the functor we defined above
140 this->_assign(other); // let derived classes assign their own stuff
141}
142
144 _data(std::move(data.data)),
145 _table(std::move(data.table)),
146 _manager(std::move(data.manager))
147{
148 RecordInitializer f = {reinterpret_cast<char *>(_data)};
149 _table->getSchema().forEach(f);
150}
151
153 getSchema().forEach([&os, this](auto const& item) {
154 os << item.field.getName() << ": " << this->get(item.key) << std::endl;
155 });
156}
157
159 record._stream(os);
160 return os;
161}
162
163} // namespace table
164} // namespace afw
165} // namespace lsst
char * data
Definition BaseRecord.cc:61
double element[2]
Definition BaseTable.cc:90
#define LSST_EXCEPT(type,...)
Create an exception with a given type.
Definition Exception.h:48
std::ostream * os
Definition Schema.cc:557
SchemaMapper * mapper
Tag types used to declare specialized field types.
Definition misc.h:31
Base class for all records.
Definition BaseRecord.h:31
Field< T >::Value get(Key< T > const &key) const
Return the value of a field for the given key.
Definition BaseRecord.h:151
void assign(BaseRecord const &other)
Copy all field values from other to this, requiring that they have equal schemas.
Schema getSchema() const
Return the Schema that holds this record's fields and keys.
Definition BaseRecord.h:80
BaseRecord(ConstructionToken const &, detail::RecordData &&data)
Construct a record with uninitialized data.
virtual void _assign(BaseRecord const &other)
Called by assign() after transferring fields to allow subclass data members to be copied.
Definition BaseRecord.h:209
virtual void _stream(std::ostream &os) const
Called by operator<<.
void forEach(F &func) const
Apply a functor to each SchemaItem in the Schema.
Definition Schema.h:214
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.
A class representing an angle.
Definition Angle.h:128
Reports invalid arguments.
Definition Runtime.h:66
Reports errors in the logical structure of the program.
Definition Runtime.h:46
T copy(T... args)
T endl(T... args)
T fill(T... args)
std::ostream & operator<<(std::ostream &os, BaseRecord const &record)
STL namespace.
Helper struct that contains the information passed from BaseTable to BaseRecord at construction.
Definition BaseTable.h:32