File TemplateInvoker.h¶

namespace lsst

Remove all non-astronomical counts from the Chunk Exposure’s pixels.

Class for a simple mapping implementing a generic AstrometryTransform.

It uses a template rather than a pointer so that the derived classes can use the specifics of the transform. The class simplePolyMapping overloads a few routines.

Forward declarations for lsst::utils::Cache

For details on the Cache class, see the Cache.h file.

A base class for image defects

Numeric constants used by the Integrate.h integrator routines.

Compute Image Statistics

Note: Gauss-Kronrod-Patterson quadrature coefficients for use in quadpack routine qng. These coefficients were calculated with 101 decimal digit arithmetic by L. W. Fullerton, Bell Labs, Nov 1981.

Note: The Statistics class itself can only handle lsst::afw::image::MaskedImage() types. The philosophy has been to handle other types by making them look like lsst::afw::image::MaskedImage() and reusing that code. Users should have no need to instantiate a Statistics object directly, but should use the overloaded makeStatistics() factory functions.

namespace utils

namespace python

class TemplateInvoker

#include <TemplateInvoker.h>

A helper class for wrapping C++ template functions as Python functions with dtype arguments.

TemplateInvoker takes a templated callable object, a pybind11::dtype object, and a sequence of supported C++ types via its nested Tag struct. The callable is invoked with a scalar argument of the type matching the dtype object. If none of the supported C++ types match, a different error callback is invoked instead.

As an example, we’ll wrap this function:

template <typename T>
T doSomething(std::string const & argument);

TemplateInvoker provides a default error callback, which we’ll use here (otherwise you’d need to pass one when constructing the TemplateInvoker).

For the main callback, we’ll define this helper struct:

struct DoSomethingHelper {

    template <typename T>
    T operator()(T) const {
        return doSomething<T>(argument);
    }

    std::string argument;
};

The pybind11 wrapper for doSomething is then another lambda that uses TemplateInvoker::apply to call the helper:

mod.def(
    "doSomething",
    [](std::string const & argument, py::dtype const & dtype) {
        return TemplateInvoker().apply(
            DoSomethingHelper{argument},
            dtype,
            TemplateInvoker::Tag<int, float, double>()
        );
    },
    "argument"_a
);

The type returned by the helper callable’s operator() can be anything pybind11 knows how to convert to Python.

While defining a full struct with a templated operator() makes it more obvious what TemplateInvoker is doing, it’s much more concise to use a universal lambda with the decltype operator. This wrapper is equivalent to the one above, but it doesn’t need DoSomethingHelper:

mod.def(
    "doSomething",
    [](std::string const & argument, py::dtype const & dtype) {
        return TemplateInvoker().apply(
            [&argument](auto t) { return doSomething<decltype(t)>(argument); },
            dtype,
            TemplateInvoker::Tag<int, float, double>()
        );
    },
    "argument"_a
);

Note that the value of t here doesn’t matter; what’s important is that its C++ type corresponds to the type passed in the dtype argument. So instead of using that value, we use the decltype operator to extract that type and use it as a template parameter.

Public Types

using OnErrorCallback = std::function<pybind11::object(pybind11::dtype const &dtype)>: Callback type for handling unmatched-type errors.

Public Functions

TemplateInvoker(OnErrorCallback onError)

Construct a TemplateInvoker that calls the given object when no match is found.

The callback should have the same signature as handleErrorDefault; the dtype actually passed from Python is passed so it can be included in error messages.

TemplateInvoker(): Construct a TemplateInvoker that calls handleErrorDefault when no match is found.

template<typename Function, typename ...TypesToTry> pybind11::object apply(Function function, pybind11::dtype const &dtype, Tag<TypesToTry...> typesToTry) const

Call and return function(static_cast<T>(0)) with the type T that matches a given NumPy dtype object.

the same as the exception safety of

function

Return

the result of calling function with the matching type, after converting it into a Python object.

Parameters

[in] function: Callable object to invoke. Must have an overloaded operator() that takes any T in the sequence TypesToTry, and a fail(py::dtype) method to handle the case where none of the given types match.
[in] dtype: NumPy dtype object indicating the template specialization to invoke.
[in] typesToTry: A Tag instance parameterized with the list of types to try to match to dtype.

Public Static Functions

static pybind11::object handleErrorDefault(pybind11::dtype const &dtype): Callback used for handling unmatched-type errors by default.

Private Functions

template<typename Function> pybind11::object _apply(Function &function, pybind11::dtype const &dtype, Tag<>) const¶

template<typename Function, typename T, typename ...A> pybind11::object _apply(Function &function, pybind11::dtype const &dtype, Tag<T, A...>) const¶

Private Members

OnErrorCallback _onError¶

template<typename ...Types> struct Tag: #include <TemplateInvoker.h>
A simple tag type used to pass one or more types as a function argument.

Navigation

File TemplateInvoker.h¶