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
Namespaces | Classes | Functions
lsst::daf::base Namespace Reference

Namespaces

 dateTime
 
 propertyContainer
 
 version
 
 yaml
 

Classes

class  DateTime
 Class for handling dates/times, including MJD, UTC, and TAI. More...
 
class  Persistable
 Base class for all persistable classes. More...
 
class  PropertyList
 Class for storing ordered metadata with comments. More...
 
class  PropertySet
 Class for storing generic metadata. More...
 

Functions

template<>
void PropertySet::add< PropertySet::Ptr > (std::string const &name, Ptr const &value)
 
template<>
void PropertySet::add< PropertySet::Ptr > (std::string const &name, std::vector< Ptr > const &value)
 
 PYBIND11_MODULE (dateTime, mod)
 
 PYBIND11_MODULE (persistable, mod)
 
 PYBIND11_MODULE (propertyList, mod)
 
 PYBIND11_MODULE (propertySet, mod)
 

Function Documentation

◆ PropertySet::add< PropertySet::Ptr >() [1/2]

template<>
void lsst::daf::base::PropertySet::add< PropertySet::Ptr > ( std::string const &  name,
Ptr const &  value 
)

◆ PropertySet::add< PropertySet::Ptr >() [2/2]

template<>
void lsst::daf::base::PropertySet::add< PropertySet::Ptr > ( std::string const &  name,
std::vector< Ptr > const &  value 
)

◆ PYBIND11_MODULE() [1/4]

lsst::daf::base::PYBIND11_MODULE ( dateTime  ,
mod   
)

Definition at line 12 of file dateTime.cc.

12  {
13  py::class_<DateTime> cls(mod, "DateTime");
14 
15  py::enum_<DateTime::Timescale>(cls, "Timescale")
16  .value("TAI", DateTime::Timescale::TAI)
17  .value("UTC", DateTime::Timescale::UTC)
18  .value("TT", DateTime::Timescale::TT)
19  .export_values();
20 
21  py::enum_<DateTime::DateSystem>(cls, "DateSystem")
22  .value("JD", DateTime::DateSystem::JD)
23  .value("MJD", DateTime::DateSystem::MJD)
24  .value("EPOCH", DateTime::DateSystem::EPOCH)
25  .export_values();
26 
27  cls.def(py::init<>())
28  .def_readonly_static("invalid_nsecs", &DateTime::invalid_nsecs)
29  .def(py::init<long long, DateTime::Timescale>(), "nsecs"_a, "scale"_a = DateTime::Timescale::TAI)
30  .def(py::init<double, DateTime::DateSystem, DateTime::Timescale>(), "date"_a,
31  "system"_a = DateTime::DateSystem::MJD, "scale"_a = DateTime::Timescale::TAI)
32  .def(py::init<int, int, int, int, int, int, DateTime::Timescale>())
33  .def(py::init<const std::string &, DateTime::Timescale>())
34  .def("nsecs", &DateTime::nsecs, "scale"_a = DateTime::Timescale::TAI)
35  .def("get", &DateTime::get, "system"_a = DateTime::DateSystem::MJD,
36  "scale"_a = DateTime::Timescale::TAI)
37  .def("toString", &DateTime::toString)
38  .def("gmtime", &DateTime::gmtime)
39  .def("timespec", &DateTime::timespec)
40  .def("timeval", &DateTime::timeval)
41  .def("isValid", &DateTime::isValid)
42  .def_static("now", &DateTime::now)
43  .def_static("initializeLeapSeconds", &DateTime::initializeLeapSeconds)
44  .def("__eq__", [](DateTime const &self, DateTime const &other) { return self == other; },
45  py::is_operator());
46 }
bool isValid
Definition: fits.cc:399

◆ PYBIND11_MODULE() [2/4]

lsst::daf::base::PYBIND11_MODULE ( persistable  ,
mod   
)

Definition at line 14 of file persistable.cc.

14  {
15  py::class_<Persistable, std::shared_ptr<Persistable>> cls(mod, "Persistable");
16 }

◆ PYBIND11_MODULE() [3/4]

lsst::daf::base::PYBIND11_MODULE ( propertyList  ,
mod   
)

Definition at line 60 of file propertyList.cc.

60  {
61  py::module::import("lsst.daf.base.persistable");
62 
63  py::class_<PropertyList, std::shared_ptr<PropertyList>, PropertySet> cls(mod, "PropertyList");
64 
65  cls.def(py::init<>());
66 
67  cls.def("getComment", &PropertyList::getComment);
68  cls.def("getOrderedNames", &PropertyList::getOrderedNames);
69  cls.def("deepCopy",
70  [](PropertyList const& self) { return std::static_pointer_cast<PropertySet>(self.deepCopy()); });
71  declareAccessors<bool>(cls, "Bool");
72  declareAccessors<short>(cls, "Short");
73  declareAccessors<int>(cls, "Int");
74  declareAccessors<long>(cls, "Long");
75  declareAccessors<long long>(cls, "LongLong");
76  declareAccessors<float>(cls, "Float");
77  declareAccessors<double>(cls, "Double");
78  declareAccessors<std::nullptr_t>(cls, "Undef");
79  declareAccessors<std::string>(cls, "String");
80  declareAccessors<DateTime>(cls, "DateTime");
81 
82  cls.def("setPropertySet",
83  (void (PropertyList::*)(std::string const&, PropertySet::Ptr const&)) & PropertyList::set);
84 }
daf::base::PropertySet * set
Definition: fits.cc:912

◆ PYBIND11_MODULE() [4/4]

lsst::daf::base::PYBIND11_MODULE ( propertySet  ,
mod   
)

Definition at line 50 of file propertySet.cc.

50  {
51  py::module::import("lsst.daf.base.persistable");
52 
53  py::class_<std::type_info>(mod, "TypeInfo")
54  .def("__eq__",
55  [](std::type_info const& self, std::type_info const& other) { return self == other; })
56  .def("__ne__",
57  [](std::type_info const& self, std::type_info const& other) { return self != other; })
58  .def("name", &std::type_info::name)
59  .def("__hash__", &std::type_info::hash_code);
60 
61  py::class_<PropertySet, std::shared_ptr<PropertySet>> cls(mod, "PropertySet");
62 
63  cls.def(py::init<bool>(), "flat"_a = false);
64 
65  cls.def("deepCopy", &PropertySet::deepCopy);
66  cls.def("nameCount", &PropertySet::nameCount, "topLevelOnly"_a = true);
67  cls.def("names", &PropertySet::names, "topLevelOnly"_a = true);
68  cls.def("paramNames", &PropertySet::paramNames, "topLevelOnly"_a = true);
69  cls.def("propertySetNames", &PropertySet::propertySetNames, "topLevelOnly"_a = true);
70  cls.def("exists", &PropertySet::exists);
71  cls.def("isArray", &PropertySet::isArray);
72  cls.def("isUndefined", &PropertySet::isUndefined);
73  cls.def("isPropertySetPtr", &PropertySet::isPropertySetPtr);
74  cls.def("valueCount",
75  py::overload_cast<>(&PropertySet::valueCount, py::const_));
76  cls.def("valueCount",
77  py::overload_cast<std::string const&>(&PropertySet::valueCount,
78  py::const_));
79  cls.def("typeOf", &PropertySet::typeOf, py::return_value_policy::reference);
80  cls.def("toString", &PropertySet::toString, "topLevelOnly"_a = false, "indent"_a = "");
81  cls.def("copy", &PropertySet::copy, "dest"_a, "source"_a, "name"_a, "asScalar"_a=false);
82  cls.def("combine", &PropertySet::combine);
83  cls.def("remove", &PropertySet::remove);
84  cls.def("getAsBool", &PropertySet::getAsBool);
85  cls.def("getAsInt", &PropertySet::getAsInt);
86  cls.def("getAsInt64", &PropertySet::getAsInt64);
87  cls.def("getAsUInt64", &PropertySet::getAsUInt64);
88  cls.def("getAsDouble", &PropertySet::getAsDouble);
89  cls.def("getAsString", &PropertySet::getAsString);
90  cls.def("getAsPropertySetPtr", &PropertySet::getAsPropertySetPtr);
91  cls.def("getAsPersistablePtr", &PropertySet::getAsPersistablePtr);
92 
93  declareAccessors<bool>(cls, "Bool");
94  declareAccessors<short>(cls, "Short");
95  declareAccessors<int>(cls, "Int");
96  declareAccessors<long>(cls, "Long");
97  declareAccessors<long long>(cls, "LongLong");
98  declareAccessors<unsigned long long>(cls, "UnsignedLongLong");
99  declareAccessors<float>(cls, "Float");
100  declareAccessors<double>(cls, "Double");
101  declareAccessors<std::nullptr_t>(cls, "Undef");
102  declareAccessors<std::string>(cls, "String");
103  declareAccessors<DateTime>(cls, "DateTime");
104  declareAccessors<std::shared_ptr<PropertySet>>(cls, "PropertySet");
105 }
T hash_code(T... args)
T name(T... args)