@ladybugmem/icebug 0.1.0

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

@@ -0,0 +1,39 @@
+/*******************************************************************************
+ * tlx/meta/is_std_pair.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_PAIR_HEADER
+#define TLX_META_IS_STD_PAIR_HEADER
+
+#include <type_traits>
+#include <utility>
+
+namespace tlx {
+
+//! \addtogroup tlx_meta
+//! \{
+
+//! test if is a std::pair<...>
+template <typename T>
+struct is_std_pair : public std::false_type
+{
+};
+
+template <typename S, typename T>
+struct is_std_pair<std::pair<S, T> > : public std::true_type
+{
+};
+
+//! \}
+
+} // namespace tlx
+
+#endif // !TLX_META_IS_STD_PAIR_HEADER
+
+/******************************************************************************/

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

@@ -0,0 +1,39 @@
+/*******************************************************************************
+ * tlx/meta/is_std_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_IS_STD_TUPLE_HEADER
+#define TLX_META_IS_STD_TUPLE_HEADER
+
+#include <tuple>
+#include <type_traits>
+
+namespace tlx {
+
+//! \addtogroup tlx_meta
+//! \{
+
+//! test if is a std::tuple<...>
+template <typename T>
+struct is_std_tuple : public std::false_type
+{
+};
+
+template <typename... Ts>
+struct is_std_tuple<std::tuple<Ts...> > : public std::true_type
+{
+};
+
+//! \}
+
+} // namespace tlx
+
+#endif // !TLX_META_IS_STD_TUPLE_HEADER
+
+/******************************************************************************/

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

@@ -0,0 +1,39 @@
+/*******************************************************************************
+ * tlx/meta/is_std_vector.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_VECTOR_HEADER
+#define TLX_META_IS_STD_VECTOR_HEADER
+
+#include <type_traits>
+#include <vector>
+
+namespace tlx {
+
+//! \addtogroup tlx_meta
+//! \{
+
+//! test if is std::vector<T>
+template <typename T>
+struct is_std_vector : public std::false_type
+{
+};
+
+template <typename T>
+struct is_std_vector<std::vector<T> > : public std::true_type
+{
+};
+
+//! \}
+
+} // namespace tlx
+
+#endif // !TLX_META_IS_STD_VECTOR_HEADER
+
+/******************************************************************************/

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

@@ -0,0 +1,101 @@
+/*******************************************************************************
+ * tlx/meta/log2.hpp
+ *
+ * Template Metaprogramming Tools (from the Generative Programming book Krysztof
+ * Czarnecki, Ulrich Eisenecker)
+ *
+ * Part of tlx - http://panthema.net/tlx
+ *
+ * Copyright (C) 2003 Roman Dementiev <dementiev@mpi-sb.mpg.de>
+ * Copyright (C) 2008 Andreas Beckmann <beckmann@cs.uni-frankfurt.de>
+ * Copyright (C) 2010-2017 Timo Bingmann <tb@panthema.net>
+ *
+ * All rights reserved. Published under the Boost Software License, Version 1.0
+ ******************************************************************************/
+
+#ifndef TLX_META_LOG2_HEADER
+#define TLX_META_LOG2_HEADER
+
+#include <cstdint>
+
+namespace tlx {
+
+//! \addtogroup tlx_meta
+//! \{
+
+/******************************************************************************/
+// Log2Floor<Value>::value
+
+template <std::uint64_t Input>
+class Log2Floor
+{
+public:
+    enum
+    {
+        value = Log2Floor<Input / 2>::value + 1
+    };
+};
+
+template <>
+class Log2Floor<1>
+{
+public:
+    enum
+    {
+        value = 0
+    };
+};
+
+template <>
+class Log2Floor<0>
+{
+public:
+    enum
+    {
+        value = 0
+    };
+};
+
+/******************************************************************************/
+// Log2<Value>::floor and Log2<Value>::ceil
+
+template <std::uint64_t Input>
+class Log2
+{
+public:
+    enum
+    {
+        floor = Log2Floor<Input>::value,
+        ceil = Log2Floor<Input - 1>::value + 1
+    };
+};
+
+template <>
+class Log2<1>
+{
+public:
+    enum
+    {
+        floor = 0,
+        ceil = 0
+    };
+};
+
+template <>
+class Log2<0>
+{
+public:
+    enum
+    {
+        floor = 0,
+        ceil = 0
+    };
+};
+
+//! \}
+
+} // namespace tlx
+
+#endif // !TLX_META_LOG2_HEADER
+
+/******************************************************************************/

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

@@ -0,0 +1,55 @@
+/*******************************************************************************
+ * tlx/meta/no_operation.hpp
+ *
+ * Part of tlx - http://panthema.net/tlx
+ *
+ * Copyright (C) 2015-2019 Timo Bingmann <tb@panthema.net>
+ *
+ * All rights reserved. Published under the Boost Software License, Version 1.0
+ ******************************************************************************/
+
+#ifndef TLX_META_NO_OPERATION_HEADER
+#define TLX_META_NO_OPERATION_HEADER
+
+namespace tlx {
+
+//! \addtogroup tlx_meta
+//! \{
+
+//! The noop functor, which takes any arguments and does nothing. This is a good
+//! default argument for lambda function parameters.
+template <typename ReturnType>
+class NoOperation
+{
+public:
+    explicit NoOperation(ReturnType return_value = ReturnType())
+        : return_value_(return_value)
+    {
+    }
+
+    ReturnType operator()(...) const noexcept
+    {
+        return return_value_;
+    }
+
+private:
+    ReturnType return_value_;
+};
+
+//! Specialized noop functor which returns a void.
+template <>
+class NoOperation<void>
+{
+public:
+    void operator()(...) const noexcept
+    {
+    }
+};
+
+//! \}
+
+} // namespace tlx
+
+#endif // !TLX_META_NO_OPERATION_HEADER
+
+/******************************************************************************/

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

@@ -0,0 +1,42 @@
+/*******************************************************************************
+ * tlx/meta/static_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_STATIC_INDEX_HEADER
+#define TLX_META_STATIC_INDEX_HEADER
+
+#include <cstddef>
+
+namespace tlx {
+
+//! \addtogroup tlx_meta
+//! \{
+
+//! Helper for call_foreach_with_index() to save the index as a compile-time
+//! index
+template <size_t Index>
+struct StaticIndex
+{
+    //! compile-time index
+    static constexpr size_t index = Index;
+
+    //! implicit conversion to a run-time index.
+    operator size_t() const
+    {
+        return index;
+    }
+};
+
+//! \}
+
+} // namespace tlx
+
+#endif // !TLX_META_STATIC_INDEX_HEADER
+
+/******************************************************************************/

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

@@ -0,0 +1,34 @@
+/*******************************************************************************
+ * tlx/meta/vexpand.hpp
+ *
+ * Part of tlx - http://panthema.net/tlx
+ *
+ * Copyright (C) 2017 Timo Bingmann <tb@panthema.net>
+ *
+ * All rights reserved. Published under the Boost Software License, Version 1.0
+ ******************************************************************************/
+
+#ifndef TLX_META_VEXPAND_HEADER
+#define TLX_META_VEXPAND_HEADER
+
+namespace tlx {
+
+//! \addtogroup tlx_meta
+//! \{
+
+/******************************************************************************/
+// vexpand(variables...) -- macro to gobble up expanded parameter packes. This
+// is obviously identical to tlx::unused() but used in a different context.
+
+template <typename... Types>
+void vexpand(Types&&...)
+{
+}
+
+//! \}
+
+} // namespace tlx
+
+#endif // !TLX_META_VEXPAND_HEADER
+
+/******************************************************************************/

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

@@ -0,0 +1,84 @@
+/*******************************************************************************
+ * tlx/meta/vmap_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_VMAP_FOR_RANGE_HEADER
+#define TLX_META_VMAP_FOR_RANGE_HEADER
+
+#include <tlx/meta/static_index.hpp>
+#include <cstddef>
+#include <tuple>
+#include <utility>
+
+namespace tlx {
+
+//! \addtogroup tlx_meta
+//! \{
+
+/******************************************************************************/
+// Variadic Template Enumerate Mapper: run a generic templated functor (like a
+// generic lambda) for each value from [Begin,End), and collect the return
+// values in a generic std::tuple.
+//
+// Called with func(StaticIndex<> index).
+
+namespace meta_detail {
+
+//! helper for vmap_for_range: general recursive case
+template <size_t Index, size_t Size, typename Functor>
+class VMapForRangeImpl
+{
+public:
+    static auto call(Functor&& f)
+    {
+        // call this index before recursion
+        auto x = std::forward<Functor>(f)(StaticIndex<Index>());
+        return std::tuple_cat(
+            std::make_tuple(std::move(x)),
+            VMapForRangeImpl<Index + 1, Size - 1, Functor>::call(
+                std::forward<Functor>(f)));
+    }
+};
+
+//! helper for vmap_for_range: base case
+template <size_t Index, typename Functor>
+class VMapForRangeImpl<Index, 0, Functor>
+{
+public:
+    static auto call(Functor&& /* f */)
+    {
+        return std::tuple<>();
+    }
+};
+
+} // namespace meta_detail
+
+//! Vmap a generic functor (like a generic lambda) for the integers [0,Size).
+template <size_t Size, typename Functor>
+auto vmap_for_range(Functor&& f)
+{
+    return meta_detail::VMapForRangeImpl<0, Size, Functor>::call(
+        std::forward<Functor>(f));
+}
+
+//! Vmap a generic functor (like a generic lambda) for the integers [Begin,End).
+template <size_t Begin, size_t End, typename Functor>
+auto vmap_for_range(Functor&& f)
+{
+    return meta_detail::VMapForRangeImpl<Begin, End - Begin, Functor>::call(
+        std::forward<Functor>(f));
+}
+
+//! \}
+
+} // namespace tlx
+
+#endif // !TLX_META_VMAP_FOR_RANGE_HEADER
+
+/******************************************************************************/

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

@@ -0,0 +1,63 @@
+/*******************************************************************************
+ * tlx/meta/vmap_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_VMAP_FOREACH_HEADER
+#define TLX_META_VMAP_FOREACH_HEADER
+
+#include <tuple>
+#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, and collect the return
+// values in a generic std::tuple.
+
+namespace meta_detail {
+
+//! helper for vmap_foreach: base case
+template <typename Functor, typename Arg>
+auto vmap_foreach_impl(Functor&& f, Arg&& arg)
+{
+    return std::make_tuple(std::forward<Functor>(f)(std::forward<Arg>(arg)));
+}
+
+//! helper for vmap_foreach: general recursive case
+template <typename Functor, typename Arg, typename... MoreArgs>
+auto vmap_foreach_impl(Functor&& f, Arg&& arg, MoreArgs&&... rest)
+{
+    auto x = std::forward<Functor>(f)(std::forward<Arg>(arg));
+    return std::tuple_cat(std::make_tuple(std::move(x)),
+                          vmap_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>
+auto vmap_foreach(Functor&& f, Args&&... args)
+{
+    return meta_detail::vmap_foreach_impl(std::forward<Functor>(f),
+                                          std::forward<Args>(args)...);
+}
+
+//! \}
+
+} // namespace tlx
+
+#endif // !TLX_META_VMAP_FOREACH_HEADER
+
+/******************************************************************************/

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

@@ -0,0 +1,59 @@
+/*******************************************************************************
+ * tlx/meta/vmap_foreach_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_VMAP_FOREACH_TUPLE_HEADER
+#define TLX_META_VMAP_FOREACH_TUPLE_HEADER
+
+#include <tlx/meta/index_sequence.hpp>
+#include <tlx/meta/vmap_foreach.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 tuple, and collect the returned values in a
+// generic std::tuple.
+
+namespace meta_detail {
+
+//! helper for vmap_foreach_tuple: forwards tuple entries
+template <typename Functor, typename Tuple, std::size_t... Is>
+auto vmap_foreach_tuple_impl(Functor&& f, Tuple&& t, index_sequence<Is...>)
+{
+    return vmap_foreach(std::forward<Functor>(f),
+                        std::get<Is>(std::forward<Tuple>(t))...);
+}
+
+} // namespace meta_detail
+
+//! Call a generic functor (like a generic lambda) for each variadic template
+//! argument and collect the result in a std::tuple<>.
+template <typename Functor, typename Tuple>
+auto vmap_foreach_tuple(Functor&& f, Tuple&& t)
+{
+    using Indices = make_index_sequence<
+        std::tuple_size<typename std::decay<Tuple>::type>::value>;
+    return meta_detail::vmap_foreach_tuple_impl(
+        std::forward<Functor>(f), std::forward<Tuple>(t), Indices());
+}
+
+//! \}
+
+} // namespace tlx
+
+#endif // !TLX_META_VMAP_FOREACH_TUPLE_HEADER
+
+/******************************************************************************/

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

@@ -0,0 +1,62 @@
+/*******************************************************************************
+ * tlx/meta/vmap_foreach_tuple_with_index.hpp
+ *
+ * Part of tlx - http://panthema.net/tlx
+ *
+ * Copyright (C) 2018 Timo Bingmann <tb@panthema.net>
+ *
+ * All rights reserved. Published under the Boost Software License, Version 1.0
+ ******************************************************************************/
+
+#ifndef TLX_META_VMAP_FOREACH_TUPLE_WITH_INDEX_HEADER
+#define TLX_META_VMAP_FOREACH_TUPLE_WITH_INDEX_HEADER
+
+#include <tlx/meta/index_sequence.hpp>
+#include <tlx/meta/vmap_foreach_with_index.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 tuple, and collect the returned values in a
+// generic std::tuple.
+//
+// Called with func(StaticIndex<> index, Argument arg).
+
+namespace meta_detail {
+
+//! helper for vmap_foreach_tuple_with_index: forwards tuple entries
+template <typename Functor, typename Tuple, std::size_t... Is>
+auto vmap_foreach_tuple_with_index_impl(Functor&& f, Tuple&& t,
+                                        index_sequence<Is...>)
+{
+    return vmap_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) for each variadic template
+//! argument and collect the result in a std::tuple<>.
+template <typename Functor, typename Tuple>
+auto vmap_foreach_tuple_with_index(Functor&& f, Tuple&& t)
+{
+    using Indices = make_index_sequence<
+        std::tuple_size<typename std::decay<Tuple>::type>::value>;
+    return meta_detail::vmap_foreach_tuple_with_index_impl(
+        std::forward<Functor>(f), std::forward<Tuple>(t), Indices());
+}
+
+//! \}
+
+} // namespace tlx
+
+#endif // !TLX_META_VMAP_FOREACH_TUPLE_WITH_INDEX_HEADER
+
+/******************************************************************************/

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

@@ -0,0 +1,70 @@
+/*******************************************************************************
+ * tlx/meta/vmap_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_VMAP_FOREACH_WITH_INDEX_HEADER
+#define TLX_META_VMAP_FOREACH_WITH_INDEX_HEADER
+
+#include <tlx/meta/static_index.hpp>
+#include <cstddef>
+#include <tuple>
+#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, and collect the return
+// values in a generic std::tuple.
+//
+// Called with func(StaticIndex<> index, Argument arg).
+
+namespace meta_detail {
+
+//! helper for vmap_foreach_with_index: base case
+template <size_t Index, typename Functor, typename Arg>
+auto vmap_foreach_with_index_impl(Functor&& f, Arg&& arg)
+{
+    return std::make_tuple(
+        std::forward<Functor>(f)(StaticIndex<Index>(), std::forward<Arg>(arg)));
+}
+
+//! helper for vmap_foreach_with_index: general recursive case
+template <size_t Index, typename Functor, typename Arg, typename... MoreArgs>
+auto vmap_foreach_with_index_impl(Functor&& f, Arg&& arg, MoreArgs&&... rest)
+{
+    auto x =
+        std::forward<Functor>(f)(StaticIndex<Index>(), std::forward<Arg>(arg));
+    return std::tuple_cat(
+        std::make_tuple(std::move(x)),
+        vmap_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>
+auto vmap_foreach_with_index(Functor&& f, Args&&... args)
+{
+    return meta_detail::vmap_foreach_with_index_impl<0>(
+        std::forward<Functor>(f), std::forward<Args>(args)...);
+}
+
+//! \}
+
+} // namespace tlx
+
+#endif // !TLX_META_VMAP_FOREACH_WITH_INDEX_HEADER
+
+/******************************************************************************/