LSSTApplications  20.0.0
LSSTDataManagementBasePackage
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 }

◆ 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 59 of file propertyList.cc.

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

◆ PYBIND11_MODULE() [4/4]

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

Definition at line 49 of file propertySet.cc.

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