LSSTApplications  19.0.0-14-gb0260a2+64befe7c1c,20.0.0+0b340dd7c4,20.0.0+1540ce6389,20.0.0+7c6b12c2f9,20.0.0+ae956f52c5,20.0.0+be870186d9,20.0.0+e2e26847c2,20.0.0-1-g04bee24+7c6b12c2f9,20.0.0-1-g10df615+fbe45b1aff,20.0.0-1-g253301a+7c6b12c2f9,20.0.0-1-g2b7511a+46a6078777,20.0.0-1-g4d801e7+9d50d6c21a,20.0.0-1-g5b95a8c+8ebfc75efb,20.0.0-1-gb058bd0+46a6078777,20.0.0-1-gb88604f+acecce4127,20.0.0-1-gc96f8cb+016e330d09,20.0.0-1-gedffbd8+83814edeba,20.0.0-10-g0891cd99+a5f14e9acb,20.0.0-10-g9a20bd332+576ca7b471,20.0.0-17-gcdbda88+0e26bfb1e6,20.0.0-2-g4dae9ad+016e330d09,20.0.0-2-g61b8584+85c46248f3,20.0.0-2-gb780d76+f45b7d88f4,20.0.0-21-g9bbb7f7+016e330d09,20.0.0-22-gc512666+f30f3883a7,20.0.0-23-g8900aa8+68630f7098,20.0.0-3-g1653f94+85c46248f3,20.0.0-3-g4cc78c6+63636aeed8,20.0.0-3-g750bffe+e05f822de9,20.0.0-3-gbd60e8c+ff10c6d78d,20.0.0-32-g15a0e07c+a4c9d0309b,20.0.0-4-g97dc21a+68630f7098,20.0.0-4-gfea843c+f45b7d88f4,20.0.0-5-g357b56b+f45b7d88f4,20.0.0-6-g9a5b7a1+b0f8c2be93,20.0.0-60-gad89340+e4dd172200,20.0.0-7-gcda7bf1+673816f70c,w.2020.43
LSSTDataManagementBasePackage
Namespaces | Classes | Typedefs | Functions
lsst::afw::typehandling Namespace Reference

Namespaces

 _GenericMap
 
 _SimpleGenericMap
 
 detail
 
 test
 
 testUtils
 

Classes

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...
 

Typedefs

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

Functions

template<typename V , typename K >
constexpr Key< K, V > makeKey (K const &id)
 Factory function for Key, to enable type parameter inference. More...
 
template<typename K , typename V >
std::ostreamoperator<< (std::ostream &os, Key< K, V > const &key)
 Output operator for Key. More...
 
void swap (PolymorphicValue &lhs, PolymorphicValue &rhs) noexcept
 Swap specialization for PolymorphicValue. More...
 
std::string declareGenericMapRestrictions (std::string const &className, std::string const &keyName)
 
std::ostreamoperator<< (std::ostream &os, Storable const &storable)
 Output operator for Storable. More...
 
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 _Storable.cc.

Function Documentation

◆ declareGenericMapRestrictions()

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

Definition at line 32 of file python.cc.

32  {
33  // Give the class a custom docstring to avoid confusing Python users
34  std::string docstring = R"docstring(
35 For compatibility with C++, ``)docstring" +
36  className + R"docstring(`` has the following restrictions:
37  - all keys must be )docstring" + keyName +
38  R"docstring(
39  - values must be built-in types or subclasses of `lsst.afw.typehandling.Storable`.
40  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)
constexpr

Factory function for Key, to enable type parameter inference.

Parameters
idthe key ID to create.
Returns
a key of the desired type
Exception Safety\n 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);
175 }

◆ 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>".

Parameters
osthe desired output stream
keythe key to print
Returns
a reference to os
Exception Safety\n Provides basic exception safety if the output operator of K is exception-safe.
Warning
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;
202 }

◆ operator<<() [2/2]

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

Output operator for Storable.

Parameters
osthe desired output stream
storablethe object to print
Returns
a reference to os
Exceptions
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();
176 }

◆ PYBIND11_MODULE()

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

Definition at line 41 of file _typehandling.cc.

41  {
42  WrapperCollection w(mod, "lsst.afw.typehandling");
43  wrapStorable(w);
46  w.finish();
47 }

◆ swap()

void swap ( PolymorphicValue lhs,
PolymorphicValue rhs 
)
inlinenoexcept

Swap specialization for PolymorphicValue.

Definition at line 152 of file PolymorphicValue.h.

152 { lhs.swap(rhs); }

◆ wrapGenericMap()

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

Definition at line 216 of file _GenericMap.cc.

216  {
217  declareGenericMap<std::string>(wrappers, "S", "strings");
218  declareMutableGenericMap<std::string>(wrappers, "S", "strings");
219 }

◆ wrapSimpleGenericMap()

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

Definition at line 79 of file _SimpleGenericMap.cc.

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

◆ wrapStorable()

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

Definition at line 43 of file _Storable.cc.

43  {
44  wrappers.addInheritanceDependency("lsst.afw.table.io");
45 
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  });
53 }
std::string
STL class.
lsst::afw::geom.transform.transformContinued.name
string name
Definition: transformContinued.py:32
lsst::afw::typehandling::wrapStorable
void wrapStorable(utils::python::WrapperCollection &wrappers)
Definition: _Storable.cc:43
std::is_volatile
lsst::afw::geom.transform.transformContinued.cls
cls
Definition: transformContinued.py:33
lsst::afw::typehandling::PyStorable
py::class_< Storable, PySharedPtr< Storable >, table::io::Persistable, StorableHelper<> > PyStorable
Definition: _Storable.cc:41
os
std::ostream * os
Definition: Schema.cc:746
std::is_const
lsst::afw::typehandling::wrapSimpleGenericMap
void wrapSimpleGenericMap(utils::python::WrapperCollection &wrappers)
Definition: _SimpleGenericMap.cc:79
key
Key< U > key
Definition: Schema.cc:281
w
double w
Definition: CoaddPsf.cc:69
lsst::afw::typehandling::wrapGenericMap
void wrapGenericMap(utils::python::WrapperCollection &wrappers)
Definition: _GenericMap.cc:216