@ladybugmem/icebug 0.1.0 → 0.1.2

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

@@ -1,55 +0,0 @@
-/*******************************************************************************
- * tlx/meta/apply_tuple.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_APPLY_TUPLE_HEADER
-#define TLX_META_APPLY_TUPLE_HEADER
-
-#include <tlx/meta/index_sequence.hpp>
-#include <cstddef>
-#include <tuple>
-#include <type_traits>
-#include <utility>
-
-namespace tlx {
-
-//! \addtogroup tlx_meta
-//! \{
-
-/******************************************************************************/
-// Tuple Applier: takes a std::tuple<> and applies a variadic template function
-// to it. Hence, this expands the content of the tuple as the arguments.
-
-namespace meta_detail {
-
-template <typename Functor, typename Tuple, std::size_t... Is>
-auto apply_tuple_impl(Functor&& f, Tuple&& t, index_sequence<Is...>)
-{
-    return std::forward<Functor>(f)(std::get<Is>(std::forward<Tuple>(t))...);
-}
-
-} // namespace meta_detail
-
-//! Call the functor f with the contents of t as arguments.
-template <typename Functor, typename Tuple>
-auto apply_tuple(Functor&& f, Tuple&& t)
-{
-    using Indices = make_index_sequence<
-        std::tuple_size<typename std::decay<Tuple>::type>::value>;
-    return meta_detail::apply_tuple_impl(std::forward<Functor>(f),
-                                         std::forward<Tuple>(t), Indices());
-}
-
-//! \}
-
-} // namespace tlx
-
-#endif // !TLX_META_APPLY_TUPLE_HEADER
-
-/******************************************************************************/

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

@@ -1,78 +0,0 @@
-/*******************************************************************************
- * tlx/meta/call_for_range.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_CALL_FOR_RANGE_HEADER
-#define TLX_META_CALL_FOR_RANGE_HEADER
-
-#include <tlx/meta/static_index.hpp>
-#include <cstddef>
-#include <utility>
-
-namespace tlx {
-
-//! \addtogroup tlx_meta
-//! \{
-
-/******************************************************************************/
-// Variadic Template Enumerator: run a generic templated functor (like a generic
-// lambda) for the integers 0 .. Size-1 or more general [Begin,End).
-//
-// Called with func(StaticIndex<> index).
-
-namespace meta_detail {
-
-//! helper for call_for_range: general recursive case
-template <size_t Index, size_t Size, typename Functor>
-class CallForRangeImpl
-{
-public:
-    static void call(Functor&& f)
-    {
-        std::forward<Functor>(f)(StaticIndex<Index>());
-        CallForRangeImpl<Index + 1, Size - 1, Functor>::call(
-            std::forward<Functor>(f));
-    }
-};
-
-//! helper for call_for_range: base case
-template <size_t Index, typename Functor>
-class CallForRangeImpl<Index, 0, Functor>
-{
-public:
-    static void call(Functor&& /* f */)
-    {
-    }
-};
-
-} // namespace meta_detail
-
-//! Call a generic functor (like a generic lambda) for the integers [0,Size).
-template <size_t Size, typename Functor>
-void call_for_range(Functor&& f)
-{
-    meta_detail::CallForRangeImpl<0, Size, Functor>::call(
-        std::forward<Functor>(f));
-}
-
-//! Call a generic functor (like a generic lambda) for the integers [Begin,End).
-template <size_t Begin, size_t End, typename Functor>
-void call_for_range(Functor&& f)
-{
-    meta_detail::CallForRangeImpl<Begin, End - Begin, Functor>::call(
-        std::forward<Functor>(f));
-}
-
-//! \}
-
-} // namespace tlx
-
-#endif // !TLX_META_CALL_FOR_RANGE_HEADER
-
-/******************************************************************************/

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

@@ -1,60 +0,0 @@
-/*******************************************************************************
- * tlx/meta/call_foreach.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_CALL_FOREACH_HEADER
-#define TLX_META_CALL_FOREACH_HEADER
-
-#include <utility>
-
-namespace tlx {
-
-//! \addtogroup tlx_meta
-//! \{
-
-/******************************************************************************/
-// Variadic Template Expander: run a generic templated functor (like a generic
-// lambda) for each of the variadic template parameters.
-
-namespace meta_detail {
-
-//! helper for call_foreach: base case
-template <typename Functor, typename Arg>
-void call_foreach_impl(Functor&& f, Arg&& arg)
-{
-    std::forward<Functor>(f)(std::forward<Arg>(arg));
-}
-
-//! helper for call_foreach: general recursive case
-template <typename Functor, typename Arg, typename... MoreArgs>
-void call_foreach_impl(Functor&& f, Arg&& arg, MoreArgs&&... rest)
-{
-    std::forward<Functor>(f)(std::forward<Arg>(arg));
-    call_foreach_impl(std::forward<Functor>(f),
-                      std::forward<MoreArgs>(rest)...);
-}
-
-} // namespace meta_detail
-
-//! Call a generic functor (like a generic lambda) for each variadic template
-//! argument.
-template <typename Functor, typename... Args>
-void call_foreach(Functor&& f, Args&&... args)
-{
-    meta_detail::call_foreach_impl(std::forward<Functor>(f),
-                                   std::forward<Args>(args)...);
-}
-
-//! \}
-
-} // namespace tlx
-
-#endif // !TLX_META_CALL_FOREACH_HEADER
-
-/******************************************************************************/

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

@@ -1,60 +0,0 @@
-/*******************************************************************************
- * tlx/meta/call_foreach_tuple.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_CALL_FOREACH_TUPLE_HEADER
-#define TLX_META_CALL_FOREACH_TUPLE_HEADER
-
-#include <tlx/meta/call_foreach.hpp>
-#include <tlx/meta/index_sequence.hpp>
-#include <cstddef>
-#include <tuple>
-#include <type_traits>
-
-namespace tlx {
-
-//! \addtogroup tlx_meta
-//! \{
-
-/******************************************************************************/
-// Variadic Template Expander: run a generic templated functor (like a generic
-// lambda) for each component of a std::tuple.
-//
-// Called with func(Argument arg).
-
-namespace meta_detail {
-
-//! helper for call_foreach_tuple
-template <typename Functor, typename Tuple, std::size_t... Is>
-void call_foreach_tuple_impl(Functor&& f, Tuple&& t, index_sequence<Is...>)
-{
-    return call_foreach(std::forward<Functor>(f),
-                        std::get<Is>(std::forward<Tuple>(t))...);
-}
-
-} // namespace meta_detail
-
-//! Call a generic functor (like a generic lambda) to each components of a tuple
-//! together with its zero-based index.
-template <typename Functor, typename Tuple>
-void call_foreach_tuple(Functor&& f, Tuple&& t)
-{
-    using Indices = make_index_sequence<
-        std::tuple_size<typename std::decay<Tuple>::type>::value>;
-    meta_detail::call_foreach_tuple_impl(std::forward<Functor>(f),
-                                         std::forward<Tuple>(t), Indices());
-}
-
-//! \}
-
-} // namespace tlx
-
-#endif // !TLX_META_CALL_FOREACH_TUPLE_HEADER
-
-/******************************************************************************/

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

@@ -1,61 +0,0 @@
-/*******************************************************************************
- * tlx/meta/call_foreach_tuple_with_index.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_CALL_FOREACH_TUPLE_WITH_INDEX_HEADER
-#define TLX_META_CALL_FOREACH_TUPLE_WITH_INDEX_HEADER
-
-#include <tlx/meta/call_foreach_with_index.hpp>
-#include <tlx/meta/index_sequence.hpp>
-#include <cstddef>
-#include <tuple>
-#include <type_traits>
-
-namespace tlx {
-
-//! \addtogroup tlx_meta
-//! \{
-
-/******************************************************************************/
-// Variadic Template Expander: run a generic templated functor (like a generic
-// lambda) for each component of a std::tuple.
-//
-// Called with func(StaticIndex<> index, Argument arg).
-
-namespace meta_detail {
-
-//! helper for call_foreach_tuple_with_index
-template <typename Functor, typename Tuple, std::size_t... Is>
-void call_foreach_tuple_with_index_impl(Functor&& f, Tuple&& t,
-                                        index_sequence<Is...>)
-{
-    return call_foreach_with_index(std::forward<Functor>(f),
-                                   std::get<Is>(std::forward<Tuple>(t))...);
-}
-
-} // namespace meta_detail
-
-//! Call a generic functor (like a generic lambda) to each components of a tuple
-//! together with its zero-based index.
-template <typename Functor, typename Tuple>
-void call_foreach_tuple_with_index(Functor&& f, Tuple&& t)
-{
-    using Indices = make_index_sequence<
-        std::tuple_size<typename std::decay<Tuple>::type>::value>;
-    meta_detail::call_foreach_tuple_with_index_impl(
-        std::forward<Functor>(f), std::forward<Tuple>(t), Indices());
-}
-
-//! \}
-
-} // namespace tlx
-
-#endif // !TLX_META_CALL_FOREACH_TUPLE_WITH_INDEX_HEADER
-
-/******************************************************************************/

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

@@ -1,64 +0,0 @@
-/*******************************************************************************
- * tlx/meta/call_foreach_with_index.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_CALL_FOREACH_WITH_INDEX_HEADER
-#define TLX_META_CALL_FOREACH_WITH_INDEX_HEADER
-
-#include <tlx/meta/static_index.hpp>
-#include <cstddef>
-#include <utility>
-
-namespace tlx {
-
-//! \addtogroup tlx_meta
-//! \{
-
-/******************************************************************************/
-// Variadic Template Expander: run a generic templated functor (like a generic
-// lambda) for each of the variadic template parameters.
-//
-// Called with func(StaticIndex<> index, Argument arg).
-
-namespace meta_detail {
-
-//! helper for call_foreach_with_index: base case
-template <size_t Index, typename Functor, typename Arg>
-void call_foreach_with_index_impl(Functor&& f, Arg&& arg)
-{
-    std::forward<Functor>(f)(StaticIndex<Index>(), std::forward<Arg>(arg));
-}
-
-//! helper for call_foreach_with_index: general recursive case
-template <size_t Index, typename Functor, typename Arg, typename... MoreArgs>
-void call_foreach_with_index_impl(Functor&& f, Arg&& arg, MoreArgs&&... rest)
-{
-    std::forward<Functor>(f)(StaticIndex<Index>(), std::forward<Arg>(arg));
-    call_foreach_with_index_impl<Index + 1>(std::forward<Functor>(f),
-                                            std::forward<MoreArgs>(rest)...);
-}
-
-} // namespace meta_detail
-
-//! Call a generic functor (like a generic lambda) for each variadic template
-//! argument together with its zero-based index.
-template <typename Functor, typename... Args>
-void call_foreach_with_index(Functor&& f, Args&&... args)
-{
-    meta_detail::call_foreach_with_index_impl<0>(std::forward<Functor>(f),
-                                                 std::forward<Args>(args)...);
-}
-
-//! \}
-
-} // namespace tlx
-
-#endif // !TLX_META_CALL_FOREACH_WITH_INDEX_HEADER
-
-/******************************************************************************/

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

@@ -1,37 +0,0 @@
-/*******************************************************************************
- * tlx/meta/enable_if.hpp
- *
- * Part of tlx - http://panthema.net/tlx
- *
- * Copyright (C) 2019 Timo Bingmann <tb@panthema.net>
- *
- * All rights reserved. Published under the Boost Software License, Version 1.0
- ******************************************************************************/
-
-#ifndef TLX_META_ENABLE_IF_HEADER
-#define TLX_META_ENABLE_IF_HEADER
-
-namespace tlx {
-
-//! \addtogroup tlx_meta
-//! \{
-
-//! SFINAE enable_if -- copy of std::enable_if<> with less extra cruft.
-template <bool, typename T = void>
-struct enable_if
-{
-};
-
-template <typename T>
-struct enable_if<true, T>
-{
-    typedef T type;
-};
-
-//! \}
-
-} // namespace tlx
-
-#endif // !TLX_META_ENABLE_IF_HEADER
-
-/******************************************************************************/

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

@@ -1,63 +0,0 @@
-/*******************************************************************************
- * tlx/meta/fold_left.hpp
- *
- * Part of tlx - http://panthema.net/tlx
- *
- * Copyright (C) 2018 Hung Tran <hung@ae.cs.uni-frankfurt.de>
- *
- * All rights reserved. Published under the Boost Software License, Version 1.0
- ******************************************************************************/
-
-#ifndef TLX_META_FOLD_LEFT_HEADER
-#define TLX_META_FOLD_LEFT_HEADER
-
-#include <utility>
-
-namespace tlx {
-
-//! \addtogroup tlx_meta
-//! \{
-
-/******************************************************************************/
-// Variadic Template Expander: Implements fold_left() on the variadic template
-// arguments. Implements (init ... op ... pack) of C++17.
-
-namespace meta_detail {
-
-//! helper for fold_left(): base case
-template <typename Reduce, typename Initial, typename Arg>
-auto fold_left_impl(Reduce&& r, Initial&& init, Arg&& arg)
-{
-    return std::forward<Reduce>(r)(std::forward<Initial>(init),
-                                   std::forward<Arg>(arg));
-}
-
-//! helper for fold_left(): general recursive case
-template <typename Reduce, typename Initial, typename Arg, typename... MoreArgs>
-auto fold_left_impl(Reduce&& r, Initial&& init, Arg&& arg, MoreArgs&&... rest)
-{
-    return fold_left_impl(std::forward<Reduce>(r),
-                          std::forward<Reduce>(r)(std::forward<Initial>(init),
-                                                  std::forward<Arg>(arg)),
-                          std::forward<MoreArgs>(rest)...);
-}
-
-} // namespace meta_detail
-
-//! Implements fold_left() -- ((a * b) * c) -- with a binary Reduce operation
-//! and initial value.
-template <typename Reduce, typename Initial, typename... Args>
-auto fold_left(Reduce&& r, Initial&& init, Args&&... args)
-{
-    return meta_detail::fold_left_impl(std::forward<Reduce>(r),
-                                       std::forward<Initial>(init),
-                                       std::forward<Args>(args)...);
-}
-
-//! \}
-
-} // namespace tlx
-
-#endif // !TLX_META_FOLD_LEFT_HEADER
-
-/******************************************************************************/

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

@@ -1,60 +0,0 @@
-/*******************************************************************************
- * tlx/meta/fold_left_tuple.hpp
- *
- * Part of tlx - http://panthema.net/tlx
- *
- * Copyright (C) 2018 Hung Tran <hung@ae.cs.uni-frankfurt.de>
- *
- * All rights reserved. Published under the Boost Software License, Version 1.0
- ******************************************************************************/
-
-#ifndef TLX_META_FOLD_LEFT_TUPLE_HEADER
-#define TLX_META_FOLD_LEFT_TUPLE_HEADER
-
-#include <tlx/meta/fold_left.hpp>
-#include <tlx/meta/index_sequence.hpp>
-#include <cstddef>
-#include <tuple>
-#include <type_traits>
-
-namespace tlx {
-
-//! \addtogroup tlx_meta
-//! \{
-
-/******************************************************************************/
-// Variadic Template Expander: Implements fold_left() on the components of a
-// tuple.
-
-namespace meta_detail {
-
-//! helper for fold_left_tuple: forwards tuple entries
-template <typename Reduce, typename Initial, typename Tuple, std::size_t... Is>
-auto fold_left_tuple_impl(Reduce&& r, Initial&& init, Tuple&& t,
-                          index_sequence<Is...>)
-{
-    return fold_left(std::forward<Reduce>(r), std::forward<Initial>(init),
-                     std::get<Is>(std::forward<Tuple>(t))...);
-}
-
-} // namespace meta_detail
-
-//! Implements fold_left() -- ((a * b) * c) -- with a binary Reduce operation
-//! and initial value on a tuple.
-template <typename Reduce, typename Initial, typename Tuple>
-auto fold_left_tuple(Reduce&& r, Initial&& init, Tuple&& t)
-{
-    using Indices = make_index_sequence<
-        std::tuple_size<typename std::decay<Tuple>::type>::value>;
-    return meta_detail::fold_left_tuple_impl(std::forward<Reduce>(r),
-                                             std::forward<Initial>(init),
-                                             std::forward<Tuple>(t), Indices());
-}
-
-//! \}
-
-} // namespace tlx
-
-#endif // !TLX_META_FOLD_LEFT_TUPLE_HEADER
-
-/******************************************************************************/

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

@@ -1,63 +0,0 @@
-/*******************************************************************************
- * tlx/meta/fold_right.hpp
- *
- * Part of tlx - http://panthema.net/tlx
- *
- * Copyright (C) 2018 Hung Tran <hung@ae.cs.uni-frankfurt.de>
- *
- * All rights reserved. Published under the Boost Software License, Version 1.0
- ******************************************************************************/
-
-#ifndef TLX_META_FOLD_RIGHT_HEADER
-#define TLX_META_FOLD_RIGHT_HEADER
-
-#include <utility>
-
-namespace tlx {
-
-//! \addtogroup tlx_meta
-//! \{
-
-/******************************************************************************/
-// Variadic Template Expander: Implements fold_right() on the variadic template
-// arguments. Implements (pack ... op ... init) of C++17.
-
-namespace meta_detail {
-
-//! helper for fold_right: base case
-template <typename Reduce, typename Initial, typename Arg>
-auto fold_right_impl(Reduce&& r, Initial&& init, Arg&& arg)
-{
-    return std::forward<Reduce>(r)(std::forward<Arg>(arg),
-                                   std::forward<Initial>(init));
-}
-
-//! helper for fold_right: general recursive case
-template <typename Reduce, typename Initial, typename Arg, typename... MoreArgs>
-auto fold_right_impl(Reduce&& r, Initial&& init, Arg&& arg, MoreArgs&&... rest)
-{
-    return std::forward<Reduce>(r)(
-        std::forward<Arg>(arg),
-        fold_right_impl(std::forward<Reduce>(r), std::forward<Initial>(init),
-                        std::forward<MoreArgs>(rest)...));
-}
-
-} // namespace meta_detail
-
-//! Implements fold_right() -- (a * (b * c)) -- with a binary Reduce operation
-//! and initial value.
-template <typename Reduce, typename Initial, typename... Args>
-auto fold_right(Reduce&& r, Initial&& init, Args&&... args)
-{
-    return meta_detail::fold_right_impl(std::forward<Reduce>(r),
-                                        std::forward<Initial>(init),
-                                        std::forward<Args>(args)...);
-}
-
-//! \}
-
-} // namespace tlx
-
-#endif // !TLX_META_FOLD_RIGHT_HEADER
-
-/******************************************************************************/

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

@@ -1,60 +0,0 @@
-/*******************************************************************************
- * tlx/meta/fold_right_tuple.hpp
- *
- * Part of tlx - http://panthema.net/tlx
- *
- * Copyright (C) 2018 Hung Tran <hung@ae.cs.uni-frankfurt.de>
- *
- * All rights reserved. Published under the Boost Software License, Version 1.0
- ******************************************************************************/
-
-#ifndef TLX_META_FOLD_RIGHT_TUPLE_HEADER
-#define TLX_META_FOLD_RIGHT_TUPLE_HEADER
-
-#include <tlx/meta/fold_right.hpp>
-#include <tlx/meta/index_sequence.hpp>
-#include <cstddef>
-#include <tuple>
-#include <type_traits>
-
-namespace tlx {
-
-//! \addtogroup tlx_meta
-//! \{
-
-/******************************************************************************/
-// Variadic Template Expander: Implements fold_right() on the components of a
-// tuple.
-
-namespace meta_detail {
-
-//! helper for fold_right_tuple: forwards tuple entries
-template <typename Reduce, typename Initial, typename Tuple, std::size_t... Is>
-auto fold_right_tuple_impl(Reduce&& r, Initial&& init, Tuple&& t,
-                           index_sequence<Is...>)
-{
-    return fold_right(std::forward<Reduce>(r), std::forward<Initial>(init),
-                      std::get<Is>(std::forward<Tuple>(t))...);
-}
-
-} // namespace meta_detail
-
-//! Implements fold_right() -- (a * (b * c)) -- with a binary Reduce operation
-//! and initial value on a tuple.
-template <typename Reduce, typename Initial, typename Tuple>
-auto fold_right_tuple(Reduce&& r, Initial&& init, Tuple&& t)
-{
-    using Indices = make_index_sequence<
-        std::tuple_size<typename std::decay<Tuple>::type>::value>;
-    return meta_detail::fold_right_tuple_impl(
-        std::forward<Reduce>(r), std::forward<Initial>(init),
-        std::forward<Tuple>(t), Indices());
-}
-
-//! \}
-
-} // namespace tlx
-
-#endif // !TLX_META_FOLD_RIGHT_TUPLE_HEADER
-
-/******************************************************************************/