LSST Applications g2079a07aa2+86d27d4dc4,g2305ad1205+a659bff248,g2bbee38e9b+3c60f8fe34,g337abbeb29+3c60f8fe34,g33d1c0ed96+3c60f8fe34,g3502564af9+d77d6d1350,g3a166c0a6a+3c60f8fe34,g487adcacf7+25d9892218,g4be5004598+d77d6d1350,g50ff169b8f+96c6868917,g52b1c1532d+585e252eca,g591dd9f2cf+4d81263f9a,g5cd07815a0+980d2b1c3b,g607f77f49a+d77d6d1350,g858d7b2824+d77d6d1350,g88963caddf+83e433e629,g99cad8db69+a4d3c48eeb,g9ddcbc5298+9a081db1e4,ga1e77700b3+bcf1af89ad,ga57fefb910+9a39d7b2d7,gae0086650b+585e252eca,gb065fddaf9+4f9fd82a2c,gb0e22166c9+60f28cb32d,gb363559e06+d84b1d3d07,gb3b7280ab2+4563d032e1,gb4b16eec92+babe958938,gba4ed39666+c2a2e4ac27,gbb8dafda3b+ed6854b564,gc120e1dc64+b72d212f87,gc28159a63d+3c60f8fe34,gc3e9b769f7+921dbcd359,gcf0d15dbbd+9a39d7b2d7,gdaeeff99f8+f9a426f77a,gddc38dedce+585e252eca,ge79ae78c31+3c60f8fe34,w.2024.21
LSST Data Management Base Package
No Matches
Namespaces | Classes | Typedefs | Functions
lsst::afw::typehandling Namespace Reference


namespace  _GenericMap
namespace  _SimpleGenericMap
namespace  detail
namespace  test
namespace  testUtils


class  GenericMap
 Interface for a heterogeneous map. More...
class  Key
 Key for type-safe lookup in a GenericMap. More...
class  MutableGenericMap
 Interface for a GenericMap that allows element addition and removal. More...
class  PolymorphicValue
 Container that passes Storable objects by value while preserving type. More...
class  SimpleGenericMap
 A GenericMap that allows insertion and deletion of arbitrary values. More...
class  Storable
 Interface supporting iteration over heterogenous containers. More...
class  StorableHelper
 "Trampoline" for Storable to let it be used as a base class in Python. More...
class  UnsupportedOperationException
 Exception thrown by Storable operations for unimplemented operations. More...


using PyStorable = py::class_<Storable, PySharedPtr<Storable>, table::io::Persistable, StorableHelper<>>


template<typename V , typename K >
constexpr Key< K, V > makeKey (K const &id)
 Factory function for Key, to enable type parameter inference.
template<typename K , typename V >
std::ostreamoperator<< (std::ostream &os, Key< K, V > const &key)
 Output operator for Key.
void swap (PolymorphicValue &lhs, PolymorphicValue &rhs) noexcept
 Swap specialization for PolymorphicValue.
std::string declareGenericMapRestrictions (std::string const &className, std::string const &keyName)
std::ostreamoperator<< (std::ostream &os, Storable const &storable)
 Output operator for Storable.
void wrapGenericMap (utils::python::WrapperCollection &wrappers)
void wrapSimpleGenericMap (utils::python::WrapperCollection &wrappers)
void wrapStorable (utils::python::WrapperCollection &wrappers)
 PYBIND11_MODULE (_typehandling, mod)

Typedef Documentation

◆ PyStorable

Definition at line 41 of file

Function Documentation

◆ declareGenericMapRestrictions()

std::string lsst::afw::typehandling::declareGenericMapRestrictions ( std::string const & className,
std::string const & keyName )

Definition at line 37 of file

37 {
38 // Give the class a custom docstring to avoid confusing Python users
39 std::string docstring = R"docstring(
40For compatibility with C++, ``)docstring" +
41 className + R"docstring(`` has the following restrictions:
42 - all keys must be )docstring" + keyName +
43 R"docstring(
44 - values must be built-in types or subclasses of `lsst.afw.typehandling.Storable`.
45 Almost any user-defined class in C++ or Python can have

◆ makeKey()

template<typename V , typename K >
constexpr Key< K, V > makeKey ( K const & id)

Factory function for Key, to enable type parameter inference.

idthe key ID to create.
a key of the desired type
Exception Safety
Provides the same exception safety as the copy-constructor of K.

Calling this function prevents you from having to explicitly name the key type:

auto key = makeKey<int>("foo");

Definition at line 173 of file Key.h.

173 {
174 return Key<K, V>(id);
Key for type-safe lookup in a GenericMap.
Definition Key.h:52

◆ operator<<() [1/2]

template<typename K , typename V >
std::ostream & operator<< ( std::ostream & os,
Key< K, V > const & key )

Output operator for Key.

The output will use C++ template notation for the key; for example, a key "foo" pointing to an int may print as "foo<int>".

osthe desired output stream
keythe key to print
a reference to os
Exception Safety
Provides basic exception safety if the output operator of K is exception-safe.
the type name is compiler-specific and may be mangled or unintuitive; for example, some compilers say "i" instead of "int"

Definition at line 196 of file Key.h.

196 {
197 static const std::string typeStr = boost::core::demangle(typeid(V).name());
198 static const std::string constStr = std::is_const<V>::value ? " const" : "";
199 static const std::string volatileStr = std::is_volatile<V>::value ? " volatile" : "";
200 os << key.getId() << "<" << typeStr << constStr << volatileStr << ">";
201 return os;
table::Key< std::string > name
std::ostream * os
constexpr K const & getId() const noexcept
Return the identifier of this field.
Definition Key.h:105

◆ operator<<() [2/2]

std::ostream & operator<< ( std::ostream & os,
Storable const & storable )

Output operator for Storable.

osthe desired output stream
storablethe object to print
a reference to os
UnsupportedOperationExceptionThrown if storable does not have an implementation of Storable::toString.

Definition at line 174 of file Storable.h.

174 {
175 return os << storable.toString();


lsst::afw::typehandling::PYBIND11_MODULE ( _typehandling ,
mod  )

Definition at line 41 of file

41 {
42 WrapperCollection w(mod, "lsst.afw.typehandling");
46 w.finish();
void wrapSimpleGenericMap(utils::python::WrapperCollection &wrappers)
void wrapStorable(utils::python::WrapperCollection &wrappers)
void wrapGenericMap(utils::python::WrapperCollection &wrappers)
double w

◆ swap()

void swap ( PolymorphicValue & lhs,
PolymorphicValue & rhs )

Swap specialization for PolymorphicValue.

Definition at line 152 of file PolymorphicValue.h.

152{ lhs.swap(rhs); }
void swap(PolymorphicValue &other) noexcept
Exchange the contents of this container and another.

◆ wrapGenericMap()

void lsst::afw::typehandling::wrapGenericMap ( utils::python::WrapperCollection & wrappers)

Definition at line 221 of file

221 {
222 declareGenericMap<std::string>(wrappers, "S", "strings");
223 declareMutableGenericMap<std::string>(wrappers, "S", "strings");

◆ wrapSimpleGenericMap()

void lsst::afw::typehandling::wrapSimpleGenericMap ( utils::python::WrapperCollection & wrappers)

Definition at line 79 of file

79 {
80 declareSimpleGenericMap<std::string>(wrappers, "S", "strings");

◆ wrapStorable()

void lsst::afw::typehandling::wrapStorable ( utils::python::WrapperCollection & wrappers)

Definition at line 43 of file

43 {
44 wrappers.addInheritanceDependency("");
46 wrappers.wrapType(PyStorable(wrappers.module, "Storable"), [](auto& mod, auto& cls) {
47 // Do not wrap methods inherited from Persistable
48 cls.def(py::init<>()); // Dummy constructor for pure-Python subclasses
49 // Do not wrap optional Storable methods; let subclasses do it as appropriate
50 cls.def("__eq__", [](Storable const& self, Storable const& other) { return self.equals(other); },
51 "other"_a);
52 });
54 wrappers.wrapType(
55 py::class_<StorableHelperFactory>(
56 wrappers.module, "StorableHelperFactory"
57 ),
58 [](auto& mod, auto& cls) {
59 cls.def(py::init<std::string&, std::string&>());
60 }
61 );
py::class_< Storable, PySharedPtr< Storable >, table::io::Persistable, StorableHelper<> > PyStorable