lsst::daf::base Namespace Reference

Namespaces
namespace	dateTime
namespace	propertyContainer
namespace	version
namespace	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< std::shared_ptr< PropertySet > > (std::string const &name, std::shared_ptr< PropertySet > const &value)
template<>
void	PropertySet::add< std::shared_ptr< PropertySet > > (std::string const &name, std::vector< std::shared_ptr< PropertySet > > const &value)
	PYBIND11_MODULE (dateTime, mod)
	PYBIND11_MODULE (persistable, mod)
	PYBIND11_MODULE (propertyList, mod)
	PYBIND11_MODULE (propertySet, mod)

Function Documentation

PropertySet::add< std::shared_ptr< PropertySet > >() [1/2]

template<>

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

PropertySet::add< std::shared_ptr< PropertySet > >() [2/2]

template<>

void lsst::daf::base::PropertySet::add< std::shared_ptr< PropertySet > >	(	std::string const &	name,
		std::vector< std::shared_ptr< PropertySet > > 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 60 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<std::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 50 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",
            py::overload_cast<>(&PropertySet::valueCount, py::const_));
    cls.def("valueCount",
            py::overload_cast<std::string const&>(&PropertySet::valueCount,
                                                  py::const_));
    cls.def("typeOf", &PropertySet::typeOf, py::return_value_policy::reference);
    cls.def("toString", &PropertySet::toString, "topLevelOnly"_a = false, "indent"_a = "");
    cls.def(
        "copy",
        py::overload_cast<std::string const &, PropertySet const &, std::string const &, bool>(
            &PropertySet::copy
        ),
        "dest"_a, "source"_a, "name"_a, "asScalar"_a=false
    );
    cls.def("combine", py::overload_cast<PropertySet const &>(&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<std::nullptr_t>(cls, "Undef");
    declareAccessors<std::string>(cls, "String");
    declareAccessors<DateTime>(cls, "DateTime");
    declareAccessors<std::shared_ptr<PropertySet>>(cls, "PropertySet");
}