@ladybugmem/icebug 0.1.0 → 0.1.1

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

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

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

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

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

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

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

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

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

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

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

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

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