gctf2023/pwn/flipper/dist/common/include/ustl/ufunction.h
2023-11-24 13:11:34 -05:00

463 lines
18 KiB
C++

// This file is part of the uSTL library, an STL implementation.
//
// Copyright (c) 2005 by Mike Sharov <msharov@users.sourceforge.net>
// This file is free software, distributed under the MIT License.
#pragma once
namespace ustl {
//----------------------------------------------------------------------
// Standard functors
//----------------------------------------------------------------------
/// \brief void-returning function abstract interface.
/// \ingroup FunctorObjects
template <typename Result>
struct void_function {
typedef Result result_type;
};
/// \brief \p Result f (\p Arg) function abstract interface.
/// \ingroup FunctorObjects
template <typename Arg, typename Result>
struct unary_function {
typedef Arg argument_type;
typedef Result result_type;
};
/// \brief \p Result f (\p Arg1, \p Arg2) function abstract interface.
/// \ingroup FunctorObjects
template <typename Arg1, typename Arg2, typename Result>
struct binary_function {
typedef Arg1 first_argument_type;
typedef Arg2 second_argument_type;
typedef Result result_type;
};
#ifndef DOXYGEN_SHOULD_SKIP_THIS
#define STD_BINARY_FUNCTOR(name, rv, func) \
template <class T> struct name : public binary_function<T,T,rv> \
{ inline rv operator()(const T& a, const T& b) const { return func; } };
#define STD_UNARY_FUNCTOR(name, rv, func) \
template <class T> struct name : public unary_function<T,rv> \
{ inline rv operator()(const T& a) const { return func; } };
#define STD_CONVERSION_FUNCTOR(name, func) \
template <class S, class D> struct name : public unary_function<S,D> \
{ inline D operator()(const S& a) const { return func; } };
STD_BINARY_FUNCTOR (plus, T, (a + b))
STD_BINARY_FUNCTOR (minus, T, (a - b))
STD_BINARY_FUNCTOR (divides, T, (a / b))
STD_BINARY_FUNCTOR (modulus, T, (a % b))
STD_BINARY_FUNCTOR (multiplies, T, (a * b))
STD_BINARY_FUNCTOR (logical_and, T, (a && b))
STD_BINARY_FUNCTOR (logical_or, T, (a || b))
STD_UNARY_FUNCTOR (logical_not, T, (!a))
STD_BINARY_FUNCTOR (bitwise_or, T, (a | b))
STD_BINARY_FUNCTOR (bitwise_and, T, (a & b))
STD_BINARY_FUNCTOR (bitwise_xor, T, (a ^ b))
STD_UNARY_FUNCTOR (bitwise_not, T, (~a))
STD_UNARY_FUNCTOR (negate, T, (-a))
STD_BINARY_FUNCTOR (equal_to, bool, (a == b))
STD_BINARY_FUNCTOR (not_equal_to, bool, (!(a == b)))
STD_BINARY_FUNCTOR (greater, bool, (b < a))
STD_BINARY_FUNCTOR (less, bool, (a < b))
STD_BINARY_FUNCTOR (greater_equal, bool, (!(a < b)))
STD_BINARY_FUNCTOR (less_equal, bool, (!(b < a)))
STD_BINARY_FUNCTOR (compare, int, (a < b ? -1 : (b < a)))
STD_UNARY_FUNCTOR (identity, T, (a))
#endif // DOXYGEN_SHOULD_SKIP_THIS
/// \brief Selects and returns the first argument.
/// \ingroup FunctorObjects
template <class T1, class T2> struct project1st : public binary_function<T1,T2,T1> { inline const T1& operator()(const T1& a, const T2&) const { return a; } };
/// \brief Selects and returns the second argument.
/// \ingroup FunctorObjects
template <class T1, class T2> struct project2nd : public binary_function<T1,T2,T2> { inline const T2& operator()(const T1&, const T2& a) const { return a; } };
//----------------------------------------------------------------------
// Generic function to functor converters.
//----------------------------------------------------------------------
/// \brief Wrapper object for unary function pointers.
/// Use the ptr_fun accessor to create this object.
/// \ingroup FunctorObjects
template <typename Arg, typename Result>
class pointer_to_unary_function : public unary_function<Arg,Result> {
public:
typedef Arg argument_type;
typedef Result result_type;
typedef Result (*pfunc_t)(Arg);
public:
explicit inline pointer_to_unary_function (pfunc_t pfn) : _pfn (pfn) {}
inline result_type operator() (argument_type v) const { return _pfn(v); }
private:
pfunc_t _pfn; ///< Pointer to the wrapped function.
};
/// \brief Wrapper object for binary function pointers.
/// Use the ptr_fun accessor to create this object.
/// \ingroup FunctorObjects
template <typename Arg1, typename Arg2, typename Result>
class pointer_to_binary_function : public binary_function<Arg1,Arg2,Result> {
public:
typedef Arg1 first_argument_type;
typedef Arg2 second_argument_type;
typedef Result result_type;
typedef Result (*pfunc_t)(Arg1, Arg2);
public:
explicit inline pointer_to_binary_function (pfunc_t pfn) : _pfn (pfn) {}
inline result_type operator() (first_argument_type v1, second_argument_type v2) const { return _pfn(v1, v2); }
private:
pfunc_t _pfn; ///< Pointer to the wrapped function.
};
/// ptr_fun(pfn) wraps function pointer pfn into a functor class that calls it.
/// \ingroup FunctorAccessors
template <typename Arg, typename Result>
inline pointer_to_unary_function<Arg,Result> ptr_fun (Result (*pfn)(Arg))
{
return pointer_to_unary_function<Arg,Result> (pfn);
}
/// ptr_fun(pfn) wraps function pointer pfn into a functor class that calls it.
/// \ingroup FunctorAccessors
template <typename Arg1, typename Arg2, typename Result>
inline pointer_to_binary_function<Arg1,Arg2,Result> ptr_fun (Result (*pfn)(Arg1,Arg2))
{
return pointer_to_binary_function<Arg1,Arg2,Result> (pfn);
}
//----------------------------------------------------------------------
// Negators.
//----------------------------------------------------------------------
/// \brief Wraps a unary function to return its logical negative.
/// Use the unary_negator accessor to create this object.
/// \ingroup FunctorObjects
template <class UnaryFunction>
class unary_negate : public unary_function<typename UnaryFunction::argument_type,
typename UnaryFunction::result_type> {
public:
typedef typename UnaryFunction::argument_type argument_type;
typedef typename UnaryFunction::result_type result_type;
public:
explicit inline unary_negate (UnaryFunction pfn) : _pfn (pfn) {}
inline result_type operator() (argument_type v) const { return !_pfn(v); }
private:
UnaryFunction _pfn;
};
/// Returns the functor that negates the result of *pfn().
/// \ingroup FunctorAccessors
template <class UnaryFunction>
inline unary_negate<UnaryFunction> unary_negator (UnaryFunction pfn)
{
return unary_negate<UnaryFunction>(pfn);
}
//----------------------------------------------------------------------
// Argument binders
//----------------------------------------------------------------------
/// \brief Converts a binary function to a unary function
/// by binding a constant value to the first argument.
/// Use the bind1st accessor to create this object.
/// \ingroup FunctorObjects
template <class BinaryFunction>
class binder1st : public unary_function<typename BinaryFunction::second_argument_type,
typename BinaryFunction::result_type> {
public:
typedef typename BinaryFunction::first_argument_type arg1_t;
typedef typename BinaryFunction::second_argument_type arg2_t;
typedef typename BinaryFunction::result_type result_t;
public:
inline binder1st (const BinaryFunction& pfn, const arg1_t& v) : _pfn (pfn), _v(v) {}
inline result_t operator()(arg2_t v2) const { return _pfn (_v, v2); }
protected:
BinaryFunction _pfn;
arg1_t _v;
};
/// \brief Converts a binary function to a unary function
/// by binding a constant value to the second argument.
/// Use the bind2nd accessor to create this object.
/// \ingroup FunctorObjects
template <class BinaryFunction>
class binder2nd : public unary_function<typename BinaryFunction::first_argument_type,
typename BinaryFunction::result_type> {
public:
typedef typename BinaryFunction::first_argument_type arg1_t;
typedef typename BinaryFunction::second_argument_type arg2_t;
typedef typename BinaryFunction::result_type result_t;
public:
inline binder2nd (const BinaryFunction& pfn, const arg2_t& v) : _pfn (pfn), _v(v) {}
inline result_t operator()(arg1_t v1) const { return _pfn (v1, _v); }
protected:
BinaryFunction _pfn;
arg2_t _v;
};
/// Converts \p pfn into a unary function by binding the first argument to \p v.
/// \ingroup FunctorAccessors
template <typename BinaryFunction>
inline binder1st<BinaryFunction>
bind1st (BinaryFunction pfn, typename BinaryFunction::first_argument_type v)
{
return binder1st<BinaryFunction> (pfn, v);
}
/// Converts \p pfn into a unary function by binding the second argument to \p v.
/// \ingroup FunctorAccessors
template <typename BinaryFunction>
inline binder2nd<BinaryFunction>
bind2nd (BinaryFunction pfn, typename BinaryFunction::second_argument_type v)
{
return binder2nd<BinaryFunction> (pfn, v);
}
//----------------------------------------------------------------------
// Composition adapters
//----------------------------------------------------------------------
/// \brief Chains two unary functions together.
///
/// When f(x) and g(x) are composed, the result is function c(x)=f(g(x)).
/// Use the \ref compose1 accessor to create this object.
/// This template is an extension, implemented by SGI STL and uSTL.
/// \ingroup FunctorObjects
///
template <typename Operation1, typename Operation2>
class unary_compose : public unary_function<typename Operation2::argument_type,
typename Operation1::result_type> {
public:
typedef typename Operation2::argument_type arg_t;
typedef const arg_t& rcarg_t;
typedef typename Operation1::result_type result_t;
public:
inline unary_compose (const Operation1& f, const Operation2& g) : _f(f), _g(g) {}
inline result_t operator() (rcarg_t x) const { return _f(_g(x)); }
protected:
Operation1 _f; ///< f(x), if c(x) = f(g(x))
Operation2 _g; ///< g(x), if c(x) = f(g(x))
};
/// Creates a \ref unary_compose object whose function c(x)=f(g(x))
/// \ingroup FunctorAccessors
template <typename Operation1, typename Operation2>
inline unary_compose<Operation1, Operation2>
compose1 (const Operation1& f, const Operation2& g)
{ return unary_compose<Operation1,Operation2>(f, g); }
/// \brief Chains two unary functions through a binary function.
///
/// When f(x,y), g(x), and h(x) are composed, the result is function
/// c(x)=f(g(x),h(x)). Use the \ref compose2 accessor to create this
/// object. This template is an extension, implemented by SGI STL and uSTL.
/// \ingroup FunctorObjects
///
template <typename Operation1, typename Operation2, typename Operation3>
class binary_compose : public unary_function<typename Operation2::argument_type,
typename Operation1::result_type> {
public:
typedef typename Operation2::argument_type arg_t;
typedef const arg_t& rcarg_t;
typedef typename Operation1::result_type result_t;
public:
inline binary_compose (const Operation1& f, const Operation2& g, const Operation3& h) : _f(f), _g(g), _h(h) {}
inline result_t operator() (rcarg_t x) const { return _f(_g(x), _h(x)); }
protected:
Operation1 _f; ///< f(x,y), if c(x) = f(g(x),h(x))
Operation2 _g; ///< g(x), if c(x) = f(g(x),h(x))
Operation3 _h; ///< h(x), if c(x) = f(g(x),h(x))
};
/// Creates a \ref binary_compose object whose function c(x)=f(g(x),h(x))
/// \ingroup FunctorAccessors
template <typename Operation1, typename Operation2, typename Operation3>
inline binary_compose<Operation1, Operation2, Operation3>
compose2 (const Operation1& f, const Operation2& g, const Operation3& h)
{ return binary_compose<Operation1, Operation2, Operation3> (f, g, h); }
//----------------------------------------------------------------------
// Member function adaptors
//----------------------------------------------------------------------
#ifndef DOXYGEN_SHOULD_SKIP_THIS
#define MEM_FUN_T(WrapperName, ClassName, ArgType, FuncType, CallType) \
template <typename Ret, class T> \
class ClassName : public unary_function<ArgType,Ret> { \
public: \
typedef Ret (T::*func_t) FuncType; \
public: \
explicit inline ClassName (func_t pf) : _pf (pf) {} \
inline Ret operator() (ArgType p) const { return (p CallType _pf)(); } \
private: \
func_t _pf; \
}; \
\
template <class Ret, typename T> \
inline ClassName<Ret,T> WrapperName (Ret (T::*pf) FuncType) \
{ \
return ClassName<Ret,T> (pf); \
}
MEM_FUN_T(mem_fun, mem_fun_t, T*, (void), ->*)
MEM_FUN_T(mem_fun, const_mem_fun_t, const T*, (void) const, ->*)
MEM_FUN_T(mem_fun_ref, mem_fun_ref_t, T&, (void), .*)
MEM_FUN_T(mem_fun_ref, const_mem_fun_ref_t, const T&, (void) const, .*)
#define EXT_MEM_FUN_T(ClassName, HostType, FuncType) \
template <class T, typename Ret, typename V> \
class ClassName : public unary_function<V,void> { \
public: \
typedef Ret (T::*func_t)(V) FuncType; \
public: \
inline ClassName (HostType t, func_t pf) : _t (t), _pf (pf) {} \
inline Ret operator() (V v) const { return (_t->*_pf)(v); } \
private: \
HostType _t; \
func_t _pf; \
}; \
\
template <class T, typename Ret, typename V> \
inline ClassName<T,Ret,V> mem_fun (HostType p, Ret (T::*pf)(V) FuncType) \
{ \
return ClassName<T,Ret,V> (p, pf); \
}
EXT_MEM_FUN_T(ext_mem_fun_t, T*, )
EXT_MEM_FUN_T(const_ext_mem_fun_t, const T*, const)
#endif // DOXYGEN_SHOULD_SKIP_THIS
//----------------------------------------------------------------------
// Member variable adaptors (uSTL extension)
//----------------------------------------------------------------------
#ifndef DOXYGEN_SHOULD_SKIP_THIS
#define MEM_VAR_T(FunctorName, ArgType, VarType, BaseClass, CallImpl) \
template <typename Function, class T, typename VT> \
class FunctorName##_t : public BaseClass { \
public: \
typedef ArgType argument_type; \
typedef typename Function::result_type result_type; \
typedef VarType mem_var_ptr_t; \
public: \
inline FunctorName##_t (mem_var_ptr_t pv, Function pfn) : _pv(pv), _pfn(pfn) {} \
inline result_type operator() CallImpl \
private: \
mem_var_ptr_t _pv; \
Function _pfn; \
}; \
\
template <typename Function, class T, typename VT> \
inline FunctorName##_t<Function, T, VT> \
FunctorName (VT T::*mvp, Function pfn) \
{ \
return FunctorName##_t<Function,T,VT> (mvp, pfn); \
}
#define FUNCTOR_UNARY_BASE(ArgType) unary_function<ArgType, typename Function::result_type>
#define FUNCTOR_BINARY_BASE(ArgType) binary_function<ArgType, ArgType, typename Function::result_type>
#define MEM_VAR_UNARY_ARGS (argument_type p) const \
{ return _pfn(p.*_pv); }
#define MEM_VAR_BINARY_ARGS (argument_type p1, argument_type p2) const \
{ return _pfn(p1.*_pv, p2.*_pv); }
MEM_VAR_T(mem_var1, T&, VT T::*, FUNCTOR_UNARY_BASE(T&), MEM_VAR_UNARY_ARGS)
MEM_VAR_T(const_mem_var1, const T&, const VT T::*, FUNCTOR_UNARY_BASE(T&), MEM_VAR_UNARY_ARGS)
MEM_VAR_T(mem_var2, T&, VT T::*, FUNCTOR_BINARY_BASE(T&), MEM_VAR_BINARY_ARGS)
MEM_VAR_T(const_mem_var2, const T&, const VT T::*, FUNCTOR_BINARY_BASE(T&), MEM_VAR_BINARY_ARGS)
#undef MEM_VAR_UNARY_ARGS
#undef MEM_VAR_BINARY_ARGS
#endif // DOXYGEN_SHOULD_SKIP_THIS
/// Returned functor passes member variable \p mvp reference of given object to equal\<VT\>.
/// \ingroup FunctorAccessors
template <class T, typename VT>
inline const_mem_var1_t<binder2nd<equal_to<VT> >, T, VT>
mem_var_equal_to (const VT T::*mvp, const VT& v)
{
return const_mem_var1_t<binder2nd<equal_to<VT> >,T,VT> (mvp, bind2nd(equal_to<VT>(), v));
}
/// Returned functor passes member variable \p mvp reference of given object to less\<VT\>.
/// \ingroup FunctorAccessors
template <class T, typename VT>
inline const_mem_var1_t<binder2nd<less<VT> >, T, VT>
mem_var_less (const VT T::*mvp, const VT& v)
{
return const_mem_var1_t<binder2nd<less<VT> >,T,VT> (mvp, bind2nd(less<VT>(), v));
}
/// Returned functor passes member variable \p mvp reference of given object to equal\<VT\>.
/// \ingroup FunctorAccessors
template <class T, typename VT>
inline const_mem_var2_t<equal_to<VT>, T, VT>
mem_var_equal_to (const VT T::*mvp)
{
return const_mem_var2_t<equal_to<VT>,T,VT> (mvp, equal_to<VT>());
}
/// Returned functor passes member variable \p mvp reference of given object to less\<VT\>.
/// \ingroup FunctorAccessors
template <class T, typename VT>
inline const_mem_var2_t<less<VT>, T, VT>
mem_var_less (const VT T::*mvp)
{
return const_mem_var2_t<less<VT>,T,VT> (mvp, less<VT>());
}
//----------------------------------------------------------------------
// Dereference adaptors (uSTL extension)
//----------------------------------------------------------------------
#ifndef DOXYGEN_SHOULD_SKIP_THIS
#define DEREFERENCER_T(ClassName, ArgType, BaseClass, CallImpl, FunctorKey) \
template <typename T, typename Function> \
class ClassName : public BaseClass { \
public: \
typedef ArgType* argument_type; \
typedef typename Function::result_type result_type; \
public: \
inline ClassName (Function pfn) : _pfn (pfn) {} \
inline result_type operator() CallImpl \
private: \
Function _pfn; \
}; \
\
template <typename T, typename Function> \
inline ClassName<T,Function> _dereference (Function pfn, FunctorKey) \
{ \
return ClassName<T,Function> (pfn); \
}
#define DEREF_UNARY_ARGS (argument_type p) const \
{ return _pfn(*p); }
#define DEREF_BINARY_ARGS (argument_type p1, argument_type p2) const \
{ return _pfn(*p1, *p2); }
DEREFERENCER_T(deref1_t, T, FUNCTOR_UNARY_BASE(T*), DEREF_UNARY_ARGS, FUNCTOR_UNARY_BASE(T))
DEREFERENCER_T(const_deref1_t, const T, FUNCTOR_UNARY_BASE(const T*), DEREF_UNARY_ARGS, FUNCTOR_UNARY_BASE(const T))
DEREFERENCER_T(deref2_t, T, FUNCTOR_BINARY_BASE(T*), DEREF_BINARY_ARGS, FUNCTOR_BINARY_BASE(T))
DEREFERENCER_T(const_deref2_t, const T, FUNCTOR_BINARY_BASE(const T*), DEREF_BINARY_ARGS, FUNCTOR_BINARY_BASE(const T))
#define dereference(f) _dereference(f,f)
#undef DEREF_UNARY_ARGS
#undef DEREF_BINARY_ARGS
#endif
} // namespace ustl