function-filter/example.cpp at master · spapiernik/function-filter · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
#define _CMP_BEGIN namespace cmp {
#define _CMP_END }

_CMP_BEGIN
template <class T>
class CompareImpl
{
  public:
        constexpr CompareImpl(T f) : func(f) {}

	template <class X0>
	constexpr decltype(auto) operator< (X0 val)
	{
		return [func_ = func, val](auto... args) {
			return func_(args...) < val;
		};
	}

	template <class X0>
	constexpr decltype(auto) operator> (X0 val)
	{
		return [func_ = func, val](auto... args) {
			return func_(args...) > val;
		};
	}

	template <class X0>
	constexpr decltype(auto) operator<= (X0 val)
	{
		return [func_ = func, val](auto... args) {
			return func_(args...) <= val;
		};
	}

	template <class X0>
	constexpr decltype(auto) operator>= (X0 val)
	{
		return [func_ = func, val](auto... args) {
			return func_(args...) >= val;
		};
	}

	template <class X0>
	constexpr decltype(auto) operator== (X0 val)
	{
		return [func_ = func, val](auto... args) {
			return func_(args...) == val;
		};
	}

	template <class X0>
	constexpr decltype(auto) operator!= (X0 val)
	{
		return [func_ = func, val](auto... args) {
			return func_(args...) != val;
		};
	}

  private:
	T func;
};

template<typename T>
constexpr auto Compare(T t = {})
{
	return CompareImpl<T>(t);
}

template<auto FuncRef>
constexpr auto Compare()
{
	return CompareImpl<decltype(FuncRef)>(FuncRef);
}

template <class X, class Y>
constexpr decltype(auto) operator&& (X lhs, Y rhs) {
	return [lhs, rhs](auto... args) {
		return lhs(args...) && rhs(args...);
	};
}

template <class X, class Y>
constexpr decltype(auto) operator|| (X lhs, Y rhs) {
	return [lhs, rhs](auto... args) {
		return lhs(args...) || rhs(args...);
	};
}

template <class X>
constexpr decltype(auto) operator!(X lhs) {
	return [lhs](auto... args) {
		return !lhs(args...);
	};
}
_CMP_END

constexpr int doubleFunc(int someArg)
{
	return someArg * 2;
}

using namespace cmp;

int main() {
	constexpr auto newFilter = cmp::Compare<doubleFunc>() >= 0 && cmp::Compare(doubleFunc) < 20;
	constexpr bool isSmallerThan20 = newFilter(5);

	return isSmallerThan20 ? 42 : 0;
}