@ladybugmem/icebug 0.1.0

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

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

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

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

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

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

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

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

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

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

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

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