Remove Activ libs and includes

This commit is contained in:
John Colvin committed 2023-12-15 13:15:08 -05:00
1 parent 28ed30c944
commit 4b718994be
10967 files changed
-2306716

No files matched your search

@@ -1,50 +0,0 @@
// Copyright (C) 2009-2012 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0
// (see accompanying file LICENSE_1_0.txt or a copy at
// http://www.boost.org/LICENSE_1_0.txt)
// Home at http://www.boost.org/libs/functional/overloaded_function
#ifndef ACTIV_BOOST_FUNCTIONAL_OVERLOADED_FUNCTION_CONFIG_HPP_
#define ACTIV_BOOST_FUNCTIONAL_OVERLOADED_FUNCTION_CONFIG_HPP_
/** @file
@brief Change the compile-time configuration of this library.
*/
/**
@brief Specify the maximum number of arguments of the functions being
overloaded.
If this macro is left undefined by the user, it has a default value of 5
(increasing this number might increase compilation time).
When specified by the user, this macro must be a non-negative integer number.
@See @RefSect{getting_started, Getting Started},
@RefClass{Boost::overloaded_function}.
*/
#ifndef ACTIV_BOOST_FUNCTIONAL_OVERLOADED_FUNCTION_CONFIG_ARITY_MAX
# define ACTIV_BOOST_FUNCTIONAL_OVERLOADED_FUNCTION_CONFIG_ARITY_MAX 5
#endif
/**
@brief Specify the maximum number of functions that can be overloaded.
If this macro is left undefined by the user, it has a default value of 5
(increasing this number might increase compilation time).
When defined by the user, this macro must be an integer number greater or
equal than 2 (because at least two distinct functions need to be specified in
order to define an overload).
@See @RefSect{getting_started, Getting Started},
@RefClass{Boost::overloaded_function}.
*/
#ifndef ACTIV_BOOST_FUNCTIONAL_OVERLOADED_FUNCTION_CONFIG_OVERLOAD_MAX
# define ACTIV_BOOST_FUNCTIONAL_OVERLOADED_FUNCTION_CONFIG_OVERLOAD_MAX 5
#endif
#if ACTIV_BOOST_FUNCTIONAL_OVERLOADED_FUNCTION_CONFIG_OVERLOAD_MAX < 2
# error "maximum overload macro cannot be less than 2"
#endif
#endif // #include guard
@@ -1,86 +0,0 @@
// Copyright (C) 2009-2012 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0
// (see accompanying file LICENSE_1_0.txt or a copy at
// http://www.boost.org/LICENSE_1_0.txt)
// Home at http://www.boost.org/libs/functional/overloaded_function
#if !ACTIV_BOOST_PP_IS_ITERATING
# ifndef ACTIV_BOOST_FUNCTIONAL_OVERLOADED_FUNCTION_DETAIL_BASE_HPP_
# define ACTIV_BOOST_FUNCTIONAL_OVERLOADED_FUNCTION_DETAIL_BASE_HPP_
# include <ActivBoost/functional/overloaded_function/config.hpp>
# include <ActivBoost/function.hpp>
# include <ActivBoost/preprocessor/iteration/iterate.hpp>
# include <ActivBoost/preprocessor/repetition/enum.hpp>
# include <ActivBoost/preprocessor/cat.hpp>
# include <ActivBoost/preprocessor/comma_if.hpp>
#define ACTIV_BOOST_FUNCTIONAL_DETAIL_arg_type(z, n, unused) \
ACTIV_BOOST_PP_CAT(A, n)
#define ACTIV_BOOST_FUNCTIONAL_DETAIL_arg_name(z, n, unused) \
ACTIV_BOOST_PP_CAT(a, n)
#define ACTIV_BOOST_FUNCTIONAL_DETAIL_arg_tparam(z, n, unused) \
typename ACTIV_BOOST_FUNCTIONAL_DETAIL_arg_type(z, n, unused)
#define ACTIV_BOOST_FUNCTIONAL_DETAIL_arg(z, n, unused) \
ACTIV_BOOST_FUNCTIONAL_DETAIL_arg_type(z, n, unused) \
ACTIV_BOOST_FUNCTIONAL_DETAIL_arg_name(z, n, unused)
#define ACTIV_BOOST_FUNCTIONAL_DETAIL_f \
R (ACTIV_BOOST_PP_ENUM(ACTIV_BOOST_FUNCTIONAL_DETAIL_arity, \
ACTIV_BOOST_FUNCTIONAL_DETAIL_arg_type, ~))
// Do not use namespace ::detail because overloaded_function is already a class.
namespace Boost { namespace overloaded_function_detail {
template<typename F>
class base {}; // Empty template cannot be used directly (only its spec).
# define ACTIV_BOOST_PP_ITERATION_PARAMS_1 \
(3, (0, ACTIV_BOOST_FUNCTIONAL_OVERLOADED_FUNCTION_CONFIG_ARITY_MAX, \
"ActivBoost/functional/overloaded_function/detail/base.hpp"))
# include ACTIV_BOOST_PP_ITERATE() // Iterate over funciton arity.
} } // namespace
#undef ACTIV_BOOST_FUNCTIONAL_DETAIL_arg_type
#undef ACTIV_BOOST_FUNCTIONAL_DETAIL_arg_name
#undef ACTIV_BOOST_FUNCTIONAL_DETAIL_arg_tparam
#undef ACTIV_BOOST_FUNCTIONAL_DETAIL_arg
#undef ACTIV_BOOST_FUNCTIONAL_DETAIL_f
# endif // #include guard
#elif ACTIV_BOOST_PP_ITERATION_DEPTH() == 1
# define ACTIV_BOOST_FUNCTIONAL_DETAIL_arity ACTIV_BOOST_PP_FRAME_ITERATION(1)
template<
typename R
ACTIV_BOOST_PP_COMMA_IF(ACTIV_BOOST_FUNCTIONAL_DETAIL_arity)
ACTIV_BOOST_PP_ENUM(ACTIV_BOOST_FUNCTIONAL_DETAIL_arity,
ACTIV_BOOST_FUNCTIONAL_DETAIL_arg_tparam, ~)
>
class base< ACTIV_BOOST_FUNCTIONAL_DETAIL_f > {
public:
/* implicit */ inline base(
// This requires specified type to be implicitly convertible to
// a Boost::function<> functor.
Boost::function< ACTIV_BOOST_FUNCTIONAL_DETAIL_f > const& f): f_(f)
{}
inline R operator()(ACTIV_BOOST_PP_ENUM(ACTIV_BOOST_FUNCTIONAL_DETAIL_arity,
ACTIV_BOOST_FUNCTIONAL_DETAIL_arg, ~)) const {
return f_(ACTIV_BOOST_PP_ENUM(ACTIV_BOOST_FUNCTIONAL_DETAIL_arity,
ACTIV_BOOST_FUNCTIONAL_DETAIL_arg_name, ~));
}
private:
Boost::function< ACTIV_BOOST_FUNCTIONAL_DETAIL_f > const f_;
};
# undef ACTIV_BOOST_FUNCTIONAL_DETAIL_arity
#endif // iteration
@@ -1,85 +0,0 @@
// Copyright (C) 2009-2012 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0
// (see accompanying file LICENSE_1_0.txt or a copy at
// http://www.boost.org/LICENSE_1_0.txt)
// Home at http://www.boost.org/libs/functional/overloaded_function
#ifndef ACTIV_BOOST_FUNCTIONAL_OVERLOADED_FUNCTION_DETAIL_FUNCTION_TYPE_HPP_
#define ACTIV_BOOST_FUNCTIONAL_OVERLOADED_FUNCTION_DETAIL_FUNCTION_TYPE_HPP_
#include <ActivBoost/function_types/is_function.hpp>
#include <ActivBoost/function_types/is_function_pointer.hpp>
#include <ActivBoost/function_types/is_function_reference.hpp>
#include <ActivBoost/function_types/function_type.hpp>
#include <ActivBoost/function_types/parameter_types.hpp>
#include <ActivBoost/function_types/result_type.hpp>
#include <ActivBoost/type_traits/remove_pointer.hpp>
#include <ActivBoost/type_traits/remove_reference.hpp>
#include <ActivBoost/function.hpp>
#include <ActivBoost/mpl/if.hpp>
#include <ActivBoost/mpl/identity.hpp>
#include <ActivBoost/mpl/pop_front.hpp>
#include <ActivBoost/mpl/push_front.hpp>
#include <ActivBoost/typeof/typeof.hpp>
// Do not use namespace ::detail because overloaded_function is already a class.
namespace Boost { namespace overloaded_function_detail {
// Requires: F is a monomorphic functor (i.e., has non-template `operator()`).
// Returns: F's function type `result_type (arg1_type, arg2_type, ...)`.
// It does not assume F typedef result_type, arg1_type, ... but needs typeof.
template<typename F>
class functor_type {
// NOTE: clang does not accept extra parenthesis `&(...)`.
typedef ACTIV_BOOST_TYPEOF_TPL(&F::operator()) call_ptr;
public:
typedef
typename Boost::function_types::function_type<
typename Boost::mpl::push_front<
typename Boost::mpl::pop_front< // Remove functor type (1st).
typename Boost::function_types::parameter_types<
call_ptr>::type
>::type
, typename Boost::function_types::result_type<call_ptr>::type
>::type
>::type
type;
};
// NOTE: When using Boost::function in Boost.Typeof emulation mode, the user
// has to register Boost::functionN instead of Boost::function in oder to
// do TYPEOF(F::operator()). That is confusing, so Boost::function is handled
// separately so it does not require any Boost.Typeof registration at all.
template<typename F>
struct functor_type< Boost::function<F> > {
typedef F type;
};
// Requires: F is a function type, pointer, reference, or monomorphic functor.
// Returns: F's function type `result_type (arg1_type, arg2_type, ...)`.
template<typename F>
struct function_type {
typedef
typename Boost::mpl::if_<Boost::function_types::is_function<F>,
Boost::mpl::identity<F>
,
typename Boost::mpl::if_<Boost::function_types::
is_function_pointer<F>,
Boost::remove_pointer<F>
,
typename Boost::mpl::if_<Boost::function_types::
is_function_reference<F>,
Boost::remove_reference<F>
, // Else, requires that F is a functor.
functor_type<F>
>::type
>::type
>::type
::type type;
};
} } // namespace
#endif // #include guard