@ladybugmem/icebug 0.1.0 → 0.1.1

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

@@ -1,197 +0,0 @@
-/*******************************************************************************
- * 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

@@ -1,189 +0,0 @@
-/*******************************************************************************
- * 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

@@ -1,80 +0,0 @@
-/*******************************************************************************
- * 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

@@ -1,117 +0,0 @@
-/*******************************************************************************
- * 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

@@ -1,66 +0,0 @@
-/*******************************************************************************
- * 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

@@ -1,40 +0,0 @@
-/*******************************************************************************
- * 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
-
-/******************************************************************************/