@ladybugmem/icebug 0.1.0

package/vendor/include/tlx/meta/function_chain.hpp

@@ -0,0 +1,197 @@
+/*******************************************************************************
+ * tlx/meta/function_chain.hpp
+ *
+ * A FunctionChain stores a sequence of lambdas or functors f_1, f_2, ... f_n,
+ * which are composed together as f_n(... f_2(f_1(x))). Each lambda/functor is
+ * called with the result of the previous. This basically implements
+ * compile-time function composition.
+ *
+ * Part of tlx - http://panthema.net/tlx
+ *
+ * Copyright (C) 2015 Sebastian Lamm <seba.lamm@gmail.com>
+ * Copyright (C) 2015-2017 Timo Bingmann <tb@panthema.net>
+ *
+ * All rights reserved. Published under the Boost Software License, Version 1.0
+ ******************************************************************************/
+
+#ifndef TLX_META_FUNCTION_CHAIN_HEADER
+#define TLX_META_FUNCTION_CHAIN_HEADER
+
+#include <tlx/meta/index_sequence.hpp>
+#include <cstddef>
+#include <tuple>
+
+namespace tlx {
+
+//! \addtogroup tlx_meta
+//! \{
+
+namespace meta_detail {
+
+/*!
+ * Base case for the chaining of functors: zero functors, returns the identity.
+ */
+static inline auto call_chain()
+{
+    return [](const auto& input) mutable -> auto { return input; };
+}
+
+/*!
+ * Base case for the chaining of functors.  The one functor receives an input
+ * element
+ *
+ * \param functor functor that represents the chain end.
+ */
+template <typename Functor>
+auto call_chain(const Functor& functor)
+{
+    // the functor is captured by non-const copy so that we can use functors
+    // with non-const operator(), i.e. stateful functors (e.g. for sampling)
+    return [functor = functor](const auto& input) mutable -> auto {
+        return functor(input);
+    };
+}
+
+/*!
+ * Recursive case for the chaining of functors.  The first functor receives an
+ * input element, and the remaining chain is applied to the result.
+ *
+ * \param functor Current functor to be chained.
+ *
+ * \param rest Remaining functors.
+ */
+template <typename Functor, typename... MoreFunctors>
+auto call_chain(const Functor& functor, const MoreFunctors&... rest)
+{
+    // the functor is captured by non-const copy so that we can use functors
+    // with non-const operator(), i.e. stateful functors (e.g. for sampling)
+    return [=, functor = functor](const auto& input) mutable -> auto {
+        return call_chain(rest...)(functor(input));
+    };
+}
+
+} // namespace meta_detail
+
+/*!
+ * A FunctionChain is a chain of functors that can be folded to a single
+ * functors.  All functors within the chain receive a single input value, which
+ * is the result of all preceding functors in the chain.
+ *
+ * The FunctionChain basically consists of a tuple that contains functors of
+ * varying types.
+ *
+ * \tparam Input_ Input to first functor functor.
+ *
+ * \tparam Functors Types of the different functors.
+ */
+template <typename... Functors>
+class FunctionChain
+{
+public:
+    //! default constructor: empty functor chain.
+    FunctionChain() = default;
+
+    /*!
+     * Initialize the function chain with a given tuple of functions.
+     *
+     * \param chain Tuple of functors.
+     */
+    explicit FunctionChain(const std::tuple<Functors...>& chain) : chain_(chain)
+    {
+    }
+
+    /*!
+     * Add a functor to the end of the chain.
+     *
+     * \tparam Functor Type of the functors.
+     *
+     * \param functor functor that should be added to the chain.
+     *
+     * \return New chain containing the previous and new functor(s).
+     */
+    template <typename Functor>
+    auto push(const Functor& functor) const
+    {
+        // append to function chain's type the new function.
+        return FunctionChain<Functors..., Functor>(
+            std::tuple_cat(chain_, std::make_tuple(functor)));
+    }
+
+    /*!
+     * Add a functor to the end of the chain. Alias for fold().
+     *
+     * \tparam Functor Type of the functors.
+     *
+     * \param functor functor that should be added to the chain.
+     *
+     * \return New chain containing the previous and new functor(s).
+     */
+    template <typename Functor>
+    auto operator&(const Functor& functor) const
+    {
+        return push(functor);
+    }
+
+    /*!
+     * Build a single functor by "folding" the chain.  Folding means
+     * that the chain is processed from front to back.
+     *
+     * \return Single "folded" functor representing the chain.
+     */
+    auto fold() const
+    {
+        return fold_chain(make_index_sequence<sizeof...(Functors)>{});
+    }
+
+    /*!
+     * Directly call the folded function chain with a value.
+     */
+    template <typename... Input>
+    auto operator()(Input&&... value) const
+    {
+        return fold()(std::move(value...));
+    }
+
+    //! Is true if the FunctionChain is empty.
+    static constexpr bool empty = (sizeof...(Functors) == 0);
+
+    //! Number of functors in the FunctionChain
+    static constexpr size_t size = sizeof...(Functors);
+
+private:
+    //! Tuple of varying type that stores all functors.
+    std::tuple<Functors...> chain_;
+
+    /*!
+     * Auxilary function for "folding" the chain.  This is needed to send all
+     * functors as parameters to the function that folds them together.
+     *
+     * \return Single "folded" functor representing the chain.
+     */
+    template <size_t... Is>
+    auto fold_chain(index_sequence<Is...>) const
+    {
+        return meta_detail::call_chain(std::get<Is>(chain_)...);
+    }
+};
+
+//! Functor chain maker. Can also be called with a lambda function.
+template <typename Functor>
+static inline auto make_function_chain(const Functor& functor)
+{
+    return FunctionChain<Functor>(std::make_tuple(functor));
+}
+
+//! Construct and empty function chain.
+static inline auto make_function_chain()
+{
+    return FunctionChain<>();
+}
+
+//! \}
+
+} // namespace tlx
+
+#endif // !TLX_META_FUNCTION_CHAIN_HEADER
+
+/******************************************************************************/

package/vendor/include/tlx/meta/function_stack.hpp

@@ -0,0 +1,189 @@
+/*******************************************************************************
+ * tlx/meta/function_stack.hpp
+ *
+ * A FunctionStack stores a sequence of lambdas or functors which _emit_ items
+ * to the next stage. Each lambda/functor is called with (item, emit) where emit
+ * is the chain of subsequent functors. This "push-down items" method is used by
+ * Thrill to enable expanding of one item to many in FlatMap().
+ *
+ * Given functors f_1, f_2, ... f_n, the FunctionStack calls f_1(x, f_2), for x,
+ * and f_1 calls f_2(y, f_3) for each y it emits.
+ *
+ * Part of tlx - http://panthema.net/tlx
+ *
+ * Copyright (C) 2015 Sebastian Lamm <seba.lamm@gmail.com>
+ * Copyright (C) 2015-2017 Timo Bingmann <tb@panthema.net>
+ *
+ * All rights reserved. Published under the Boost Software License, Version 1.0
+ ******************************************************************************/
+
+#ifndef TLX_META_FUNCTION_STACK_HEADER
+#define TLX_META_FUNCTION_STACK_HEADER
+
+#include <tlx/meta/index_sequence.hpp>
+#include <cstddef>
+#include <tuple>
+
+namespace tlx {
+
+//! \addtogroup tlx_meta
+//! \{
+
+namespace meta_detail {
+
+/*!
+ * Base case for the chaining of functors.  The last functor receives an input
+ * element, no emitter and should have no return type.  It should therefore
+ * store the input parameter externally.
+ *
+ * \param functor Functor that represents the chain end.
+ */
+template <typename Functor>
+auto call_stack(const Functor& functor)
+{
+    // the functor object is captured by non-const copy so that we can use
+    // functors with non-const operator(), i.e. stateful functors (e.g. for
+    // sampling)
+    return [=, functor = functor](const auto& input) mutable -> void {
+        functor(input);
+    };
+}
+
+/*!
+ * Recursive case for the chaining of functors.  The given functor receives an
+ * input element, an emitter and should have no return type.  The emitter will
+ * be built using the chain of remaining functors.
+ *
+ * \param functor Current functor to be chained.
+ *
+ * \param rest Remaining functors.
+ */
+template <typename Functor, typename... MoreFunctors>
+auto call_stack(const Functor& functor, const MoreFunctors&... rest)
+{
+    // the functor object is captured by non-const copy so that we can use
+    // functors with non-const operator(), i.e. stateful functors (e.g. for
+    // sampling)
+    return [=, functor = functor](const auto& input) mutable -> void {
+        functor(input, call_stack(rest...));
+    };
+}
+
+} // namespace meta_detail
+
+/*!
+ * A FunctionStack is a chain of functor that can be folded to a single functor
+ * (which is usually optimize by the compiler).
+ *
+ * All functors within the chain receive a single input value and a emitter
+ * function.  The emitter function is used for chaining functors together by
+ * enabling items to pushed down the sequence.  The single exception to this is
+ * the last functor, which receives no emitter, and hence usually stores the
+ * items somehow.
+ *
+ * The FunctionStack basically consists of a tuple that contains functor objects
+ * of varying types.
+ *
+ * \tparam Input_ Input to first functor.
+ *
+ * \tparam Functors Types of the different functor.
+ */
+template <typename Input_, typename... Functors>
+class FunctionStack
+{
+public:
+    using Input = Input_;
+
+    //! Construct an empty FunctionStack
+    FunctionStack() = default;
+
+    /*!
+     * Initialize the function stack with a given tuple of functors.
+     *
+     * \param stack Tuple of functor.
+     */
+    explicit FunctionStack(const std::tuple<Functors...>& stack) : stack_(stack)
+    {
+    }
+
+    /*!
+     * Add a functor function to the end of the stack.
+     *
+     * \tparam Functor Type of the functor.
+     *
+     * \param functor Functor that should be added to the stack.
+     *
+     * \return New stack containing the previous and new functor(s).
+     */
+    template <typename Functor>
+    auto push(const Functor& functor) const
+    {
+        // append to function stack's type the new function.
+        return FunctionStack<Input, Functors..., Functor>(
+            std::tuple_cat(stack_, std::make_tuple(functor)));
+    }
+
+    /*!
+     * Add a functor to the end of the stack. Alias for push().
+     *
+     * \tparam Functor Type of the functors.
+     *
+     * \param functor functor that should be added to the stack.
+     *
+     * \return New stack containing the previous and new functor(s).
+     */
+    template <typename Functor>
+    auto operator&(const Functor& functor) const
+    {
+        return push(functor);
+    }
+
+    /*!
+     * Build a single functor by "folding" the stack.  Folding means that the
+     * stack is processed from front to back and each emitter is composed using
+     * previous functors.
+     *
+     * \return Single "folded" functor representing the whole stack.
+     */
+    auto fold() const
+    {
+        return fold_stack(make_index_sequence<sizeof...(Functors)>{});
+    }
+
+    //! Is true if the FunctionStack is empty.
+    static constexpr bool empty = (sizeof...(Functors) == 0);
+
+    //! Number of functors on the FunctionStack
+    static constexpr size_t size = sizeof...(Functors);
+
+private:
+    //! Tuple of varying type that stores all functor objects functions.
+    std::tuple<Functors...> stack_;
+
+    /*!
+     * Auxilary function for "folding" the stack.  This is needed to send all
+     * functors as parameters to the function that folds them together.
+     *
+     * \return Single "folded" functor representing the stack.
+     */
+    template <size_t... Is>
+    auto fold_stack(index_sequence<Is...>) const
+    {
+        return meta_detail::call_stack(std::get<Is>(stack_)...);
+    }
+};
+
+//! Function-style construction of a FunctionStack
+template <typename Input, typename Functor>
+static inline auto make_function_stack(const Functor& functor)
+{
+    return FunctionStack<Input, Functor>(std::make_tuple(functor));
+}
+
+//! \}
+
+} // namespace tlx
+
+#endif // !TLX_META_FUNCTION_STACK_HEADER
+
+/******************************************************************************/

package/vendor/include/tlx/meta/has_member.hpp

@@ -0,0 +1,80 @@
+/*******************************************************************************
+ * tlx/meta/has_member.hpp
+ *
+ * Part of tlx - http://panthema.net/tlx
+ *
+ * Copyright (C) 2016-2017 Timo Bingmann <tb@panthema.net>
+ *
+ * All rights reserved. Published under the Boost Software License, Version 1.0
+ ******************************************************************************/
+
+#ifndef TLX_META_HAS_MEMBER_HEADER
+#define TLX_META_HAS_MEMBER_HEADER
+
+namespace tlx {
+
+//! \addtogroup tlx_meta
+//! \{
+
+/******************************************************************************/
+// SFINAE check whether a class member exists.
+
+// based on http://stackoverflow.com/questions/257288/is-it-possible
+// -to-write-a-c-template-to-check-for-a-functions-existence
+
+/*!
+ * Macro template for class member / attribute SFINAE test
+
+ Usage:
+ \code
+ TLX_MAKE_HAS_METHOD(myfunc);
+
+ static_assert(has_method_myfunc<MyClass>::value,
+               "check MyClass for existence of attribute/method myfunc");
+ \endcode
+*/
+#define TLX_MAKE_HAS_MEMBER(Member)                                            \
+    template <typename Type>                                                   \
+    class has_member_##Member                                                  \
+    {                                                                          \
+        template <typename C>                                                  \
+        static char test(decltype(&C::Member));                                \
+        template <typename C>                                                  \
+        static int test(...);                                                  \
+                                                                               \
+    public:                                                                    \
+        static const bool value = sizeof(test<Type>(0)) == sizeof(char);       \
+    }
+
+/*!
+ * Macro template for class template member SFINAE test
+
+ Usage:
+ \code
+ TLX_MAKE_HAS_TEMPLATE_METHOD(myfunc);
+
+ static_assert(has_method_myfunc<MyClass, float, int>::value,
+               "check MyClass for existence of attribute/method myfunc "
+               "if instantiated with <float, int>");
+ \endcode
+*/
+#define TLX_MAKE_HAS_TEMPLATE_MEMBER(Member)                                   \
+    template <typename Type, typename... Args>                                 \
+    class has_member_##Member                                                  \
+    {                                                                          \
+        template <typename C>                                                  \
+        static char test(decltype(&C::template Member<Args...>));              \
+        template <typename C>                                                  \
+        static int test(...);                                                  \
+                                                                               \
+    public:                                                                    \
+        static const bool value = sizeof(test<Type>(0)) == sizeof(char);       \
+    }
+
+//! \}
+
+} // namespace tlx
+
+#endif // !TLX_META_HAS_MEMBER_HEADER
+
+/******************************************************************************/

package/vendor/include/tlx/meta/has_method.hpp

@@ -0,0 +1,117 @@
+/*******************************************************************************
+ * tlx/meta/has_method.hpp
+ *
+ * Part of tlx - http://panthema.net/tlx
+ *
+ * Copyright (C) 2016-2017 Timo Bingmann <tb@panthema.net>
+ *
+ * All rights reserved. Published under the Boost Software License, Version 1.0
+ ******************************************************************************/
+
+#ifndef TLX_META_HAS_METHOD_HEADER
+#define TLX_META_HAS_METHOD_HEADER
+
+namespace tlx {
+
+//! \addtogroup tlx_meta
+//! \{
+
+/******************************************************************************/
+// SFINAE check whether a class method is callable with given parameter types.
+
+/*!
+ * Macro template for callable class method SFINAE test.
+
+ Usage:
+ \code
+ TLX_MAKE_HAS_METHOD(myfunc);
+
+ static_assert(has_method_myfunc<MyClass, int(std::string)>::value,
+               "check MyClass for existence of myfunc "
+               "with signature int(std::string)");
+ \endcode
+*/
+#define TLX_MAKE_HAS_METHOD(Method)                                            \
+    template <typename Class, typename Signature>                              \
+    class has_method_##Method;                                                 \
+                                                                               \
+    template <typename Class, typename Return, typename... Args>               \
+    class has_method_##Method<Class, Return(Args...)>                          \
+    {                                                                          \
+        template <typename C>                                                  \
+        static char test(                                                      \
+            decltype(static_cast<Return (C::*)(Args...)>(&C::Method)));        \
+        template <typename C>                                                  \
+        static int test(...);                                                  \
+                                                                               \
+    public:                                                                    \
+        static const bool value = (sizeof(test<Class>(0)) == sizeof(char));    \
+    }
+
+/*!
+ * Macro template for callable class method SFINAE test.
+
+ Usage:
+ \code
+ TLX_MAKE_HAS_STATIC_METHOD(myfunc);
+
+ static_assert(has_method_myfunc<MyClass, int(std::string)>::value,
+               "check MyClass for existence of static myfunc "
+               "with signature int(std::string)");
+ \endcode
+*/
+#define TLX_MAKE_HAS_STATIC_METHOD(Method)                                     \
+    template <typename Class, typename Signature>                              \
+    class has_method_##Method;                                                 \
+                                                                               \
+    template <typename Class, typename Return, typename... Args>               \
+    class has_method_##Method<Class, Return(Args...)>                          \
+    {                                                                          \
+        template <typename C>                                                  \
+        static char test(                                                      \
+            decltype(static_cast<Return (*)(Args...)>(&C::Method)));           \
+        template <typename C>                                                  \
+        static int test(...);                                                  \
+                                                                               \
+    public:                                                                    \
+        static const bool value = (sizeof(test<Class>(0)) == sizeof(char));    \
+    }
+
+/*!
+ * Macro template for callable class method SFINAE test.
+
+ Usage:
+ \code
+ TLX_MAKE_HAS_TEMPLATE_METHOD(myfunc);
+
+ static_assert(has_method_myfunc<MyClass, int(std::string), float, int>::value,
+               "check MyClass for existence of template myfunc "
+               "with signature int(std::string) "
+               "if the template method is instantiated with <float, int>");
+ \endcode
+*/
+#define TLX_MAKE_HAS_TEMPLATE_METHOD(Method)                                   \
+    template <typename Class, typename Signature, typename... Cons>            \
+    class has_method_##Method;                                                 \
+                                                                               \
+    template <typename Class, typename Return, typename... Args,               \
+              typename... Cons>                                                \
+    class has_method_##Method<Class, Return(Args...), Cons...>                 \
+    {                                                                          \
+        template <typename C>                                                  \
+        static char test(decltype(static_cast<Return (C::*)(Args...)>(         \
+            &C::template Method<Cons...>)));                                   \
+        template <typename C>                                                  \
+        static int test(...);                                                  \
+                                                                               \
+    public:                                                                    \
+        static const bool value = (sizeof(test<Class>(0)) == sizeof(char));    \
+    }
+
+//! \}
+
+} // namespace tlx
+
+#endif // !TLX_META_HAS_METHOD_HEADER
+
+/******************************************************************************/

package/vendor/include/tlx/meta/index_sequence.hpp

@@ -0,0 +1,66 @@
+/*******************************************************************************
+ * tlx/meta/index_sequence.hpp
+ *
+ * Part of tlx - http://panthema.net/tlx
+ *
+ * Copyright (C) 2016-2017 Timo Bingmann <tb@panthema.net>
+ *
+ * All rights reserved. Published under the Boost Software License, Version 1.0
+ ******************************************************************************/
+
+#ifndef TLX_META_INDEX_SEQUENCE_HEADER
+#define TLX_META_INDEX_SEQUENCE_HEADER
+
+#include <cstddef>
+
+namespace tlx {
+
+//! \addtogroup tlx_meta
+//! \{
+
+// Compile-time integer sequences, an implementation of std::index_sequence and
+// std::make_index_sequence, as these are not available in many current
+// libraries (MS Visual C++).
+template <size_t... Indexes>
+struct index_sequence
+{
+    static size_t size()
+    {
+        return sizeof...(Indexes);
+    }
+};
+
+namespace meta_detail {
+
+template <size_t CurrentIndex, size_t... Indexes>
+struct make_index_sequence_helper;
+
+template <size_t... Indexes>
+struct make_index_sequence_helper<0, Indexes...>
+{
+    using type = index_sequence<Indexes...>;
+};
+
+template <size_t CurrentIndex, size_t... Indexes>
+struct make_index_sequence_helper
+{
+    using type =
+        typename make_index_sequence_helper<CurrentIndex - 1, CurrentIndex - 1,
+                                            Indexes...>::type;
+};
+
+} // namespace meta_detail
+
+template <size_t Size>
+struct make_index_sequence
+    : public meta_detail::make_index_sequence_helper<Size>::type
+{
+};
+
+//! \}
+
+} // namespace tlx
+
+#endif // !TLX_META_INDEX_SEQUENCE_HEADER
+
+/******************************************************************************/

package/vendor/include/tlx/meta/is_std_array.hpp

@@ -0,0 +1,40 @@
+/*******************************************************************************
+ * tlx/meta/is_std_array.hpp
+ *
+ * Part of tlx - http://panthema.net/tlx
+ *
+ * Copyright (C) 2016-2017 Timo Bingmann <tb@panthema.net>
+ *
+ * All rights reserved. Published under the Boost Software License, Version 1.0
+ ******************************************************************************/
+
+#ifndef TLX_META_IS_STD_ARRAY_HEADER
+#define TLX_META_IS_STD_ARRAY_HEADER
+
+#include <array>
+#include <cstddef>
+#include <type_traits>
+
+namespace tlx {
+
+//! \addtogroup tlx_meta
+//! \{
+
+//! test if is std::array<T, N>
+template <typename T>
+struct is_std_array : public std::false_type
+{
+};
+
+template <typename T, size_t N>
+struct is_std_array<std::array<T, N> > : public std::true_type
+{
+};
+
+//! \}
+
+} // namespace tlx
+
+#endif // !TLX_META_IS_STD_ARRAY_HEADER
+
+/******************************************************************************/