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.

                               {
    py::class_<DateTime> cls(mod, "DateTime");
 
    py::enum_<DateTime::Timescale>(cls, "Timescale")
            .value("TAI", DateTime::Timescale::TAI)
            .value("UTC", DateTime::Timescale::UTC)
            .value("TT", DateTime::Timescale::TT)
            .export_values();
 
    py::enum_<DateTime::DateSystem>(cls, "DateSystem")
            .value("JD", DateTime::DateSystem::JD)
            .value("MJD", DateTime::DateSystem::MJD)
            .value("EPOCH", DateTime::DateSystem::EPOCH)
            .export_values();
 
    cls.def(py::init<>())
            .def_readonly_static("invalid_nsecs", &DateTime::invalid_nsecs)
            .def(py::init<long long, DateTime::Timescale>(), "nsecs"_a, "scale"_a = DateTime::Timescale::TAI)
            .def(py::init<double, DateTime::DateSystem, DateTime::Timescale>(), "date"_a,
                 "system"_a = DateTime::DateSystem::MJD, "scale"_a = DateTime::Timescale::TAI)
            .def(py::init<int, int, int, int, int, int, DateTime::Timescale>())
            .def(py::init<const std::string &, DateTime::Timescale>())
            .def("nsecs", &DateTime::nsecs, "scale"_a = DateTime::Timescale::TAI)
            .def("get", &DateTime::get, "system"_a = DateTime::DateSystem::MJD,
                 "scale"_a = DateTime::Timescale::TAI)
            .def("toString", &DateTime::toString)
            .def("gmtime", &DateTime::gmtime)
            .def("timespec", &DateTime::timespec)
            .def("timeval", &DateTime::timeval)
            .def("isValid", &DateTime::isValid)
            .def_static("now", &DateTime::now)
            .def_static("initializeLeapSeconds", &DateTime::initializeLeapSeconds)
            .def("__eq__", [](DateTime const &self, DateTime const &other) { return self == other; },
                 py::is_operator());
}

PYBIND11_MODULE() [2/4]

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

Definition at line 14 of file persistable.cc.

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

PYBIND11_MODULE() [3/4]

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

Definition at line 59 of file propertyList.cc.

                                   {
    py::module::import("lsst.daf.base.persistable");
 
    py::class_<PropertyList, std::shared_ptr<PropertyList>, PropertySet> cls(mod, "PropertyList");
 
    cls.def(py::init<>());
 
    cls.def("getComment", &PropertyList::getComment);
    cls.def("getOrderedNames", &PropertyList::getOrderedNames);
    cls.def("deepCopy",
            [](PropertyList const& self) { return std::static_pointer_cast<PropertySet>(self.deepCopy()); });
    declareAccessors<bool>(cls, "Bool");
    declareAccessors<short>(cls, "Short");
    declareAccessors<int>(cls, "Int");
    declareAccessors<long>(cls, "Long");
    declareAccessors<long long>(cls, "LongLong");
    declareAccessors<float>(cls, "Float");
    declareAccessors<double>(cls, "Double");
    declareAccessors<nullptr_t>(cls, "Undef");
    declareAccessors<std::string>(cls, "String");
    declareAccessors<DateTime>(cls, "DateTime");
 
    cls.def("setPropertySet",
            (void (PropertyList::*)(std::string const&, PropertySet::Ptr const&)) & PropertyList::set);
}

PYBIND11_MODULE() [4/4]

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

Definition at line 49 of file propertySet.cc.

                                  {
    py::module::import("lsst.daf.base.persistable");
 
    py::class_<std::type_info>(mod, "TypeInfo")
            .def("__eq__",
                 [](std::type_info const& self, std::type_info const& other) { return self == other; })
            .def("__ne__",
                 [](std::type_info const& self, std::type_info const& other) { return self != other; })
            .def("name", &std::type_info::name)
            .def("__hash__", &std::type_info::hash_code);
 
    py::class_<PropertySet, std::shared_ptr<PropertySet>> cls(mod, "PropertySet");
 
    cls.def(py::init<bool>(), "flat"_a = false);
 
    cls.def("deepCopy", &PropertySet::deepCopy);
    cls.def("nameCount", &PropertySet::nameCount, "topLevelOnly"_a = true);
    cls.def("names", &PropertySet::names, "topLevelOnly"_a = true);
    cls.def("paramNames", &PropertySet::paramNames, "topLevelOnly"_a = true);
    cls.def("propertySetNames", &PropertySet::propertySetNames, "topLevelOnly"_a = true);
    cls.def("exists", &PropertySet::exists);
    cls.def("isArray", &PropertySet::isArray);
    cls.def("isUndefined", &PropertySet::isUndefined);
    cls.def("isPropertySetPtr", &PropertySet::isPropertySetPtr);
    cls.def("valueCount", &PropertySet::valueCount);
    cls.def("typeOf", &PropertySet::typeOf, py::return_value_policy::reference);
    cls.def("toString", &PropertySet::toString, "topLevelOnly"_a = false, "indent"_a = "");
    cls.def("copy", &PropertySet::copy, "dest"_a, "source"_a, "name"_a, "asScalar"_a=false);
    cls.def("combine", &PropertySet::combine);
    cls.def("remove", &PropertySet::remove);
    cls.def("getAsBool", &PropertySet::getAsBool);
    cls.def("getAsInt", &PropertySet::getAsInt);
    cls.def("getAsInt64", &PropertySet::getAsInt64);
    cls.def("getAsUInt64", &PropertySet::getAsUInt64);
    cls.def("getAsDouble", &PropertySet::getAsDouble);
    cls.def("getAsString", &PropertySet::getAsString);
    cls.def("getAsPropertySetPtr", &PropertySet::getAsPropertySetPtr);
    cls.def("getAsPersistablePtr", &PropertySet::getAsPersistablePtr);
 
    declareAccessors<bool>(cls, "Bool");
    declareAccessors<short>(cls, "Short");
    declareAccessors<int>(cls, "Int");
    declareAccessors<long>(cls, "Long");
    declareAccessors<long long>(cls, "LongLong");
    declareAccessors<unsigned long long>(cls, "UnsignedLongLong");
    declareAccessors<float>(cls, "Float");
    declareAccessors<double>(cls, "Double");
    declareAccessors<nullptr_t>(cls, "Undef");
    declareAccessors<std::string>(cls, "String");
    declareAccessors<DateTime>(cls, "DateTime");
    declareAccessors<std::shared_ptr<PropertySet>>(cls, "PropertySet");
}