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)
void	wrapPersistable (WrapperCollection &wrappers)
void	wrapDateTime (WrapperCollection &wrappers)
void	wrapPropertyList (WrapperCollection &wrappers)
void	wrapPropertySet (WrapperCollection &wrappers)
	PYBIND11_MODULE (_dafBaseLib, 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()

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

Definition at line 37 of file _dafBaseLib.cc.

                                  {
    lsst::cpputils::python::WrapperCollection wrappers(mod, "lsst.daf.base");
    wrapPersistable(wrappers);
    wrapDateTime(wrappers);
    wrapPropertySet(wrappers);
    wrapPropertyList(wrappers);
    wrappers.finish();
}

wrapDateTime()

void lsst::daf::base::wrapDateTime

(

WrapperCollection &

wrappers

)

Definition at line 12 of file dateTime.cc.

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

wrapPersistable()

void lsst::daf::base::wrapPersistable

(

WrapperCollection &

wrappers

)

Definition at line 12 of file persistable.cc.

                                                                    {
    using PyPersistable = py::class_<Persistable, std::shared_ptr<Persistable>>;
    wrappers.wrapType(PyPersistable(wrappers.module,  "Persistable"), [] (auto &mod, auto &cls) {
    });
}

wrapPropertyList()

void lsst::daf::base::wrapPropertyList

(

WrapperCollection &

wrappers

)

Definition at line 61 of file propertyList.cc.

                                                                     {
    using PyPropertyList =  py::class_<PropertyList, std::shared_ptr<PropertyList>, PropertySet>;
    wrappers.wrapType(PyPropertyList(wrappers.module, "PropertyList"), [](auto &mod, auto &cls) {
        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);
    });
}

wrapPropertySet()

void lsst::daf::base::wrapPropertySet

(

WrapperCollection &

wrappers

)

Definition at line 51 of file propertySet.cc.

                                                                     {
    wrappers.wrapType(py::class_<std::type_info>(wrappers.module, "TypeInfo"), [](auto &mod, auto &cls) {
        cls.def("__eq__",
                [](std::type_info const &self, std::type_info const &other) { return self == other; });
        cls.def("__ne__",
                [](std::type_info const &self, std::type_info const &other) { return self != other; });
        cls.def("name", &std::type_info::name);
        cls.def("__hash__", &std::type_info::hash_code);
    });
 
     using PyPropertySet = py::class_<PropertySet, std::shared_ptr<PropertySet>>;
     wrappers.wrapType(PyPropertySet(wrappers.module, "PropertySet"), [](auto &mod, auto &cls) {
         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");
     });
}