lsst::afw::typehandling Namespace Reference

Namespaces
namespace	_GenericMap
namespace	_SimpleGenericMap
namespace	detail
namespace	test
namespace	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::ostream &	operator<< (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::ostream &	operator<< (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

using lsst::afw::typehandling::PyStorable = typedef py::class_<Storable, PySharedPtr<Storable>, table::io::Persistable, StorableHelper<> >

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.

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

id	the key ID to create.

Returns

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.

                                         {
    return Key<K, V>(id);
}

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

os	the desired output stream
key	the key to print

Returns

a reference to os

Exception Safety

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.

                                                             {
    static const std::string typeStr = boost::core::demangle(typeid(V).name());
    static const std::string constStr = std::is_const<V>::value ? " const" : "";
    static const std::string volatileStr = std::is_volatile<V>::value ? " volatile" : "";
    os << key.getId() << "<" << typeStr << constStr << volatileStr << ">";
    return os;
}

operator<<() [2/2]

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

inline

Output operator for Storable.

Parameters

os	the desired output stream
storable	the object to print

Returns

a reference to os

Exceptions

UnsupportedOperationException

Thrown if storable does not have an implementation of Storable::toString.

Definition at line 174 of file Storable.h.

                                                                        {
    return os << storable.toString();
}

PYBIND11_MODULE()

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

Definition at line 41 of file _typehandling.cc.

                                    {
    WrapperCollection w(mod, "lsst.afw.typehandling");
    wrapStorable(w);
    wrapGenericMap(w);
    wrapSimpleGenericMap(w);
    w.finish();
}

swap()

void swap ( PolymorphicValue &  lhs, PolymorphicValue &  rhs  )

inlinenoexcept

Swap specialization for PolymorphicValue.

Definition at line 152 of file PolymorphicValue.h.

{ lhs.swap(rhs); }

wrapGenericMap()

void lsst::afw::typehandling::wrapGenericMap

(

utils::python::WrapperCollection &

wrappers

)

Definition at line 221 of file _GenericMap.cc.

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

wrapSimpleGenericMap()

void lsst::afw::typehandling::wrapSimpleGenericMap

(

utils::python::WrapperCollection &

wrappers

)

Definition at line 79 of file _SimpleGenericMap.cc.

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

wrapStorable()

void lsst::afw::typehandling::wrapStorable

(

utils::python::WrapperCollection &

wrappers

)

Definition at line 43 of file _Storable.cc.

                                                          {
    wrappers.addInheritanceDependency("lsst.afw.table.io");
 
    wrappers.wrapType(PyStorable(wrappers.module, "Storable"), [](auto& mod, auto& cls) {
        // Do not wrap methods inherited from Persistable
        cls.def(py::init<>());  // Dummy constructor for pure-Python subclasses
        // Do not wrap optional Storable methods; let subclasses do it as appropriate
        cls.def("__eq__", [](Storable const& self, Storable const& other) { return self.equals(other); },
                "other"_a);
    });
 
    wrappers.wrapType(
        py::class_<StorableHelperFactory>(
            wrappers.module, "StorableHelperFactory"
        ),
        [](auto& mod, auto& cls) {
            cls.def(py::init<std::string&, std::string&>());
        }
    );
}