lsst::daf::base Namespace Reference

Namespaces
	citizen
	dateTime
	propertyContainer
	version
	yaml

Classes
class	Citizen
	Citizen is a class that should be among all LSST classes base classes, and handles basic memory management. More...
class	DateTime
	Class for handling dates/times, including MJD, UTC, and TAI. More...
class	Persistable
	Base class for all persistable classes. More...
class	PersistentCitizenScope
	A PersistentCitizenScope object causes all Citizen objects created during its lifetime to be marked as persistent. 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 (citizen, mod)
	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/5]

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/5]

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

Definition at line 12 of file citizen.cc.

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

    cls.def("repr", &Citizen::repr);
    cls.def("markPersistent", &Citizen::markPersistent);
    cls.def_static("census", (int (*)(int, Citizen::memId)) & Citizen::census);
    cls.def_static("census", (const std::vector<const Citizen *> *(*)()) & Citizen::census,
                   py::return_value_policy::reference);
    /* It is strange to expose cout to Python, so instead make a new wrapper */
    cls.def_static("census", [](Citizen::memId id) { Citizen::census(std::cout, id); });
    // TODO: pybind11 can't handle an owning pointer to a container of non-owning pointers
    // ::reference is a temporary workaround until we figure out a better way
    cls.def_static("census", (std::vector<Citizen const *> const *(*)()) & Citizen::census,
                   py::return_value_policy::reference);
    cls.def("getId", &Citizen::getId);
    cls.def("markPersistent", &Citizen::markPersistent);
    cls.def_static("getNextMemId", &Citizen::getNextMemId);
    cls.def_static("setNewCallbackId", &Citizen::setNewCallbackId);
    cls.def_static("setDeleteCallbackId", &Citizen::setDeleteCallbackId);
}

PYBIND11_MODULE() [3/5]

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() [4/5]

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>, Citizen> 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");
}

PYBIND11_MODULE() [5/5]

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, Citizen> 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);
}