From: TimePath <andrew.hardaker1995@gmail.com>
Date: Sun, 31 Dec 2017 15:16:35 +0000 (+1100)
Subject: Callback: work at any arity
X-Git-Url: http://git.xonotic.org/?p=xonotic%2Fnetradiant.git;a=commitdiff_plain;h=f6b4543bd54926411cb71a776bc5b37eea846c4f

Callback: work at any arity
---

diff --git a/include/icamera.h b/include/icamera.h
index e9becbae..36cc24f1 100644
--- a/include/icamera.h
+++ b/include/icamera.h
@@ -29,7 +29,7 @@
 #define INCLUDED_ICAMERA_H
 
 #include "generic/constant.h"
-#include "generic/callbackfwd.h"
+#include "generic/callback.h"
 
 class Matrix4;
 
diff --git a/include/ifilesystem.h b/include/ifilesystem.h
index f497528f..605aba29 100644
--- a/include/ifilesystem.h
+++ b/include/ifilesystem.h
@@ -24,7 +24,7 @@
 
 #include <cstddef>
 #include "generic/constant.h"
-#include "generic/callbackfwd.h"
+#include "generic/callback.h"
 
 typedef Callback1<const char*> ArchiveNameCallback;
 typedef Callback1<const char*> FileNameCallback;
diff --git a/include/irender.h b/include/irender.h
index 8b0c3ec6..fbba51db 100644
--- a/include/irender.h
+++ b/include/irender.h
@@ -23,7 +23,7 @@
 #define INCLUDED_IRENDER_H
 
 #include "generic/constant.h"
-#include "generic/callbackfwd.h"
+#include "generic/callback.h"
 
 
 // Rendering states to sort by.
diff --git a/include/iselection.h b/include/iselection.h
index a5951f9a..898a9aa1 100644
--- a/include/iselection.h
+++ b/include/iselection.h
@@ -24,7 +24,7 @@
 
 #include <cstddef>
 #include "generic/constant.h"
-#include "generic/callbackfwd.h"
+#include "generic/callback.h"
 #include "signal/signalfwd.h"
 
 class Renderer;
diff --git a/include/ishaders.h b/include/ishaders.h
index ac447090..e66c9c7b 100644
--- a/include/ishaders.h
+++ b/include/ishaders.h
@@ -23,7 +23,7 @@
 #define INCLUDED_ISHADERS_H
 
 #include "generic/constant.h"
-#include "generic/callbackfwd.h"
+#include "generic/callback.h"
 
 enum
 {
diff --git a/include/iundo.h b/include/iundo.h
index eb1e8681..25fa1489 100644
--- a/include/iundo.h
+++ b/include/iundo.h
@@ -27,7 +27,7 @@
 
 #include <cstddef>
 #include "generic/constant.h"
-#include "generic/callbackfwd.h"
+#include "generic/callback.h"
 
 class UndoMemento
 {
diff --git a/include/mapfile.h b/include/mapfile.h
index df1ab36f..7d61f6ed 100644
--- a/include/mapfile.h
+++ b/include/mapfile.h
@@ -25,7 +25,7 @@
 #include <limits>
 
 #include "iscenegraph.h"
-#include "generic/callbackfwd.h"
+#include "generic/callback.h"
 
 const std::size_t MAPFILE_MAX_CHANGES = std::numeric_limits<std::size_t>::max();
 
diff --git a/include/modelskin.h b/include/modelskin.h
index a2c219e6..90fef945 100644
--- a/include/modelskin.h
+++ b/include/modelskin.h
@@ -23,7 +23,7 @@
 #define INCLUDED_MODELSKIN_H
 
 #include "generic/constant.h"
-#include "generic/callbackfwd.h"
+#include "generic/callback.h"
 
 class SkinRemap
 {
diff --git a/include/nameable.h b/include/nameable.h
index bbc6f899..e295e5c6 100644
--- a/include/nameable.h
+++ b/include/nameable.h
@@ -23,7 +23,7 @@
 #define INCLUDED_NAMEABLE_H
 
 #include "generic/constant.h"
-#include "generic/callbackfwd.h"
+#include "generic/callback.h"
 
 typedef Callback1<const char*> NameCallback;
 
diff --git a/include/namespace.h b/include/namespace.h
index 9a00793c..f87a2e06 100644
--- a/include/namespace.h
+++ b/include/namespace.h
@@ -23,7 +23,7 @@
 #define INCLUDED_NAMESPACE_H
 
 #include "generic/constant.h"
-#include "generic/callbackfwd.h"
+#include "generic/callback.h"
 
 typedef Callback1<const char*> NameCallback;
 typedef Callback1<const NameCallback&> NameCallbackCallback;
diff --git a/include/preferencesystem.h b/include/preferencesystem.h
index 45678024..bbc838ad 100644
--- a/include/preferencesystem.h
+++ b/include/preferencesystem.h
@@ -23,7 +23,7 @@
 #define INCLUDED_PREFERENCESYSTEM_H
 
 #include "generic/constant.h"
-#include "generic/callbackfwd.h"
+#include "generic/callback.h"
 
 typedef Callback1<const char*> StringImportCallback;
 typedef Callback1<const StringImportCallback&> StringExportCallback;
diff --git a/include/selectable.h b/include/selectable.h
index 2b8eab07..1cea909f 100644
--- a/include/selectable.h
+++ b/include/selectable.h
@@ -26,7 +26,7 @@
 
 #include "generic/vector.h"
 #include "scenelib.h"
-#include "generic/callbackfwd.h"
+#include "generic/callback.h"
 
 class SelectionIntersection
 {
diff --git a/libs/generic/CMakeLists.txt b/libs/generic/CMakeLists.txt
index b872d874..d89f5743 100644
--- a/libs/generic/CMakeLists.txt
+++ b/libs/generic/CMakeLists.txt
@@ -2,7 +2,6 @@ add_library(generic
         arrayrange.h
         bitfield.h
         callback.cpp callback.h
-        callbackfwd.h
         constant.cpp constant.h
         enumeration.h
         functional.h
diff --git a/libs/generic/callback.h b/libs/generic/callback.h
index 4110691e..1e8cd46d 100644
--- a/libs/generic/callback.h
+++ b/libs/generic/callback.h
@@ -27,7 +27,6 @@
 
 #include <cstddef>
 #include "functional.h"
-#include "callbackfwd.h"
 
 template<typename Type>
 inline void* convertToOpaque( Type* t ){
@@ -150,6 +149,9 @@ public:
 template<class Caller>
 using BindFirstOpaque = BindFirstOpaqueN<Caller, get_func<Caller>>;
 
+/// \brief Combines a void pointer with a pointer to a function which operates on a void pointer.
+///
+/// Use with the callback constructors MemberCaller, ConstMemberCaller, ReferenceCaller, ConstReferenceCaller, PointerCaller, ConstPointerCaller and FreeCaller.
 template<class F>
 class CallbackN;
 
@@ -178,226 +180,205 @@ public:
 	}
 };
 
-/// \brief Combines a void pointer with a pointer to a function which operates on a void pointer.
-///
-/// Use with the callback constructors MemberCaller, ConstMemberCaller, ReferenceCaller, ConstReferenceCaller, PointerCaller, ConstPointerCaller and FreeCaller.
-template<class Result>
-class Callback0 : public CallbackN<Result()> {
-public:
-	using CallbackN<Result()>::CallbackN;
-};
+namespace detail {
+	template<class F>
+	struct Arglist;
 
-template<typename Caller>
-inline Callback0<get_result_type<Caller>> makeCallback0(const Caller &caller, get_argument<Caller, 0> callee) {
-	return Callback0<get_result_type<Caller>>(BindFirstOpaque<Caller>(callee));
-}
-template<typename Caller>
-inline Callback0<get_result_type<Caller>> makeStatelessCallback0(const Caller &caller) {
-	return makeCallback0( Caller0To1<Caller>(), 0 );
-}
+	template<class R, class Head, class... Ts>
+	struct Arglist<R(Head, Ts...)> {
+		using type = R(Head, Ts...);
 
-typedef Callback0<void> Callback;
+		template <class Unshift>
+		using unshift = Arglist<R(Unshift, Head, Ts...)>;
 
+		using shift = Arglist<R(Ts...)>;
+	};
 
+	template<class R, class... Ts>
+	struct Arglist<R(Ts...)> {
+		using type = R(Ts...);
 
-/// \brief Combines a void pointer with a pointer to a function which operates on a void pointer and one other argument.
-///
-/// Use with the callback constructors MemberCaller1, ConstMemberCaller1, ReferenceCaller1, ConstReferenceCaller1, PointerCaller1, ConstPointerCaller1 and FreeCaller1.
-template<class FirstArgument, class Result>
-class Callback1 : public CallbackN<Result(FirstArgument)> {
-public:
-	using CallbackN<Result(FirstArgument)>::CallbackN;
-};
-
-template<typename Caller>
-inline Callback1<get_argument<Caller, 1>, get_result_type<Caller>>
-makeCallback1(const Caller &caller, get_argument<Caller, 0> callee) {
-	return Callback1<get_argument<Caller, 1>, get_result_type<Caller>>(BindFirstOpaque<Caller>(callee));
+		template <class Unshift>
+		using unshift = Arglist<R(Unshift, Ts...)>;
+	};
 }
-template<typename Caller>
-inline Callback1<get_argument<Caller, 1>, get_result_type<Caller>> makeStatelessCallback1(const Caller &caller) {
-	return makeCallback1( Caller1To2<Caller>(), 0 );
-}
-
-
-/// \brief Combines a void pointer with a pointer to a function which operates on a void pointer and two other arguments.
-///
-template<typename FirstArgument, typename SecondArgument, typename Result>
-class Callback2 : public CallbackN<Result(FirstArgument, SecondArgument)> {
-public:
-	using CallbackN<Result(FirstArgument, SecondArgument)>::CallbackN;
-};
 
 template<typename Caller>
-inline Callback2<
-		get_argument<Caller, 1>,
-		get_argument<Caller, 2>,
-		get_result_type<Caller>
-> makeCallback2(const Caller &caller, get_argument<Caller, 0> callee) {
-	return Callback2<
-			get_argument<Caller, 1>,
-			get_argument<Caller, 2>,
-			get_result_type<Caller>
-	>(BindFirstOpaque<Caller>(callee));
+inline CallbackN<typename detail::Arglist<get_func<Caller>>::shift::type> makeCallbackN(const Caller &caller, get_argument<Caller, 0> callee) {
+	return CallbackN<typename detail::Arglist<get_func<Caller>>::shift::type>(BindFirstOpaque<Caller>(callee));
 }
+
 template<typename Caller>
-inline Callback2<
-		get_argument<Caller, 0>,
-		get_argument<Caller, 1>,
-		get_result_type<Caller>
-> makeStatelessCallback2(const Caller &caller) {
-	return makeCallback2( Caller2To3<Caller>(), 0 );
+inline CallbackN<get_func<Caller>> makeStatelessCallbackN(const Caller &caller) {
+	return makeCallbackN(CallerShiftFirst<Caller, typename detail::Arglist<get_func<Caller>>::template unshift<void *>::type>(), nullptr);
 }
 
+namespace detail {
+	template<class Object, class F>
+	struct MemberFunction;
 
-/// \brief Combines a void pointer with a pointer to a function which operates on a void pointer and three other arguments.
-///
-template<typename FirstArgument, typename SecondArgument, typename ThirdArgument, typename Result>
-class Callback3 : public CallbackN<Result(FirstArgument, SecondArgument, ThirdArgument)> {
-public:
-	using CallbackN<Result(FirstArgument, SecondArgument, ThirdArgument)>::CallbackN;
-};
-
-template<typename Caller>
-inline Callback3<
-		get_argument<Caller, 1>,
-		get_argument<Caller, 2>,
-		get_argument<Caller, 3>,
-		get_result_type<Caller>
-> makeCallback3(const Caller &caller, get_argument<Caller, 0> callee) {
-	return Callback3<
-			get_argument<Caller, 1>,
-			get_argument<Caller, 2>,
-			get_argument<Caller, 3>,
-			get_result_type<Caller>
-	>(BindFirstOpaque<Caller>(callee));
-}
-template<typename Caller>
-inline Callback3<
-		get_argument<Caller, 0>,
-		get_argument<Caller, 1>,
-		get_argument<Caller, 2>,
-		get_result_type<Caller>
-> makeStatelessCallback3(const Caller &caller) {
-	return makeCallback3( Caller3To4<Caller>(), 0 );
+	template<class Object, class R, class... Ts>
+	struct MemberFunction<Object, R(Ts...)> {
+		using type = R(Object::*)(Ts...);
+		using type_const = R(Object::*)(Ts...) const;
+	};
 }
 
+template<class Object, class F>
+using MemberFunction = typename detail::MemberFunction<Object, F>::type;
+
+template<class Object, class F>
+using ConstMemberFunction = typename detail::MemberFunction<Object, F>::type_const;
 
 /// \brief Forms a Callback from a non-const Environment reference and a non-const Environment member-function.
 ///
 /// \dontinclude generic/callback.cpp
 /// \skipline MemberCaller example
 /// \until end example
-template<class Environment, void(Environment::*member)()>
-using MemberCaller = BindFirstOpaque<Member<Environment, void, member>>;
+
+template<class Environment, class F, MemberFunction<Environment, F> member>
+using MemberCallerN = BindFirstOpaque<typename MemberN<Environment, F>::template instance<member>>;
 
 /// \brief Forms a Callback from a const Environment reference and a const Environment member-function.
 ///
 /// \dontinclude generic/callback.cpp
 /// \skipline MemberCaller example
 /// \until end example
-template<class Environment, void(Environment::*member)() const>
-using ConstMemberCaller = BindFirstOpaque<ConstMember<Environment, void, member>>;
-
-/// \brief Forms a Callback from a non-const Environment reference and a const Environment member-function which takes one argument.
-template<class Environment, class FirstArgument, void(Environment::*member)(FirstArgument)>
-using MemberCaller1 = BindFirstOpaque<Member1<Environment, FirstArgument, void, member>>;
-
-/// \brief Forms a Callback from a const Environment reference and a const Environment member-function which takes one argument.
-template<class Environment, class FirstArgument, void(Environment::*member)(FirstArgument) const>
-using ConstMemberCaller1 = BindFirstOpaque<ConstMember1<Environment, FirstArgument, void, member>>;
+template<class Environment, class F, ConstMemberFunction<Environment, F> member>
+using ConstMemberCallerN = BindFirstOpaque<typename ConstMemberN<Environment, F>::template instance<member>>;
 
 /// \brief Forms a Callback from a non-const Environment reference and a free function which operates on a non-const Environment reference.
 ///
 /// \dontinclude generic/callback.cpp
 /// \skipline ReferenceCaller example
 /// \until end example
-template<class Environment, void(*func)(Environment &)>
-using ReferenceCaller = BindFirstOpaque<Function1<Environment &, void, func>>;
+template<class Environment, class F, typename detail::Arglist<F>::template unshift<Environment &>::type *func>
+using ReferenceCallerN = BindFirstOpaque<typename FunctionN<typename detail::Arglist<F>::template unshift<Environment &>::type>::template instance<func>>;
 
 /// \brief Forms a Callback from a const Environment reference and a free function which operates on a const Environment reference.
 ///
 /// \dontinclude generic/callback.cpp
 /// \skipline ReferenceCaller example
 /// \until end example
+template<class Environment, class F, typename detail::Arglist<F>::template unshift<const Environment &>::type *func>
+using ConstReferenceCallerN = BindFirstOpaque<typename FunctionN<typename detail::Arglist<F>::template unshift<const Environment &>::type>::template instance<func>>;
+
+/// \brief Forms a Callback from a non-const Environment pointer and a free function which operates on a non-const Environment pointer.
+template<class Environment, class F, typename detail::Arglist<F>::template unshift<Environment *>::type *func>
+using PointerCallerN = BindFirstOpaque<typename FunctionN<typename detail::Arglist<F>::template unshift<Environment *>::type>::template instance<func>>;
+
+/// \brief Forms a Callback from a const Environment pointer and a free function which operates on a const Environment pointer.
+template<class Environment, class F, typename detail::Arglist<F>::template unshift<const Environment *>::type *func>
+using ConstPointerCallerN = BindFirstOpaque<typename FunctionN<typename detail::Arglist<F>::template unshift<const Environment *>::type>::template instance<func>>;
+
+/// \brief Forms a Callback from a free function
+template<class F, F *func>
+class FreeCallerN : public BindFirstOpaque<CallerShiftFirst<
+        typename FunctionN<F>::template instance<func>,
+        typename detail::Arglist<F>::template unshift<void *>::type
+>> {
+public:
+    FreeCallerN()
+            : BindFirstOpaque<CallerShiftFirst<
+            typename FunctionN<F>::template instance<func>,
+            typename detail::Arglist<F>::template unshift<void *>::type
+    >>(nullptr) {
+    }
+};
+
+/// \brief  Constructs a Callback1 from a non-const \p functor
+///
+/// \param Functor Must define \c first_argument_type and \c operator()(first_argument_type).
+template<typename Functor>
+inline CallbackN<get_func<Functor>> makeCallbackN(Functor &functor) {
+	return CallbackN<get_func<Functor>>(MemberCallerN<Functor, get_func<Functor>, &Functor::operator()>(functor));
+}
+
+/// \brief  Constructs a Callback1 from a const \p functor
+///
+/// \param Functor Must define \c first_argument_type and const \c operator()(first_argument_type).
+template<typename Functor>
+inline CallbackN<get_func<Functor>> makeCallbackN(const Functor &functor) {
+	return CallbackN<get_func<Functor>>(ConstMemberCallerN<Functor, get_func<Functor>, &Functor::operator()>(functor));
+}
+
+// todo: inline
+
+#define makeCallback makeCallbackN
+
+using Callback = CallbackN<void()>;
+
+template<class Result>
+using Callback0 = CallbackN<Result()>;
+
+template<class FirstArgument, class Result = void>
+using Callback1 = CallbackN<Result(FirstArgument)>;
+
+template<typename FirstArgument, typename SecondArgument, typename Result = void>
+using Callback2 = CallbackN<Result(FirstArgument, SecondArgument)>;
+
+template<typename FirstArgument, typename SecondArgument, typename ThirdArgument, typename Result = void>
+using Callback3 = CallbackN<Result(FirstArgument, SecondArgument, ThirdArgument)>;
+
+#define makeCallback0 makeCallbackN
+#define makeStatelessCallback0 makeStatelessCallbackN
+
+#define makeCallback1 makeCallbackN
+#define makeStatelessCallback1 makeStatelessCallbackN
+
+#define makeCallback2 makeCallbackN
+#define makeStatelessCallback2 makeStatelessCallbackN
+
+#define makeCallback3 makeCallbackN
+#define makeStatelessCallback3 makeStatelessCallbackN
+
+template<class Environment, void(Environment::*member)()>
+using MemberCaller = MemberCallerN<Environment, void(), member>;
+
+template<class Environment, void(Environment::*member)() const>
+using ConstMemberCaller = ConstMemberCallerN<Environment, void(), member>;
+
+template<class Environment, class FirstArgument, void(Environment::*member)(FirstArgument)>
+using MemberCaller1 = MemberCallerN<Environment, void(FirstArgument), member>;
+
+template<class Environment, class FirstArgument, void(Environment::*member)(FirstArgument) const>
+using ConstMemberCaller1 = ConstMemberCallerN<Environment, void(FirstArgument), member>;
+
+template<class Environment, void(*func)(Environment &)>
+using ReferenceCaller = ReferenceCallerN<Environment, void(), func>;
+
 template<class Environment, void(*func)(const Environment &)>
-using ConstReferenceCaller = BindFirstOpaque<Function1<const Environment &, void, func>>;
+using ConstReferenceCaller = ConstReferenceCallerN<Environment, void(), func>;
 
 /// \brief Forms a Callback from a non-const Environment reference and a free function which operates on a non-const Environment reference and one other argument.
 template<class Environment, class FirstArgument, void(*func)(Environment &, FirstArgument)>
-using ReferenceCaller1 = BindFirstOpaque<Function2<Environment &, FirstArgument, void, func>>;
+using ReferenceCaller1 = ReferenceCallerN<Environment, void(FirstArgument), func>;
 
 /// \brief Forms a Callback from a const Environment reference and a free function which operates on a const Environment reference and one other argument.
 template<class Environment, class FirstArgument, void(*func)(const Environment &, FirstArgument)>
-using ConstReferenceCaller1 = BindFirstOpaque<Function2<const Environment &, FirstArgument, void, func>>;
+using ConstReferenceCaller1 = ConstReferenceCallerN<Environment, void(FirstArgument), func>;
 
 /// \brief Forms a Callback from a non-const Environment pointer and a free function which operates on a non-const Environment pointer.
 template<class Environment, void(*func)(Environment *)>
-using PointerCaller = BindFirstOpaque<Function1<Environment *, void, func>>;
+using PointerCaller = PointerCallerN<Environment, void(), func>;
 
 /// \brief Forms a Callback from a const Environment pointer and a free function which operates on a const Environment pointer.
 template<class Environment, void(*func)(const Environment *)>
-using ConstPointerCaller = BindFirstOpaque<Function1<const Environment *, void, func>>;
+using ConstPointerCaller = ConstPointerCallerN<Environment, void(), func>;
 
 /// \brief Forms a Callback from a non-const Environment pointer and a free function which operates on a non-const Environment pointer and one other argument.
 template<class Environment, class FirstArgument, void(*func)(Environment *, FirstArgument)>
-using PointerCaller1 = BindFirstOpaque<Function2<Environment *, FirstArgument, void, func>>;
+using PointerCaller1 = PointerCallerN<Environment, void(FirstArgument), func>;
 
 /// \brief Forms a Callback from a const Environment pointer and a free function which operates on a const Environment pointer and one other argument.
 template<class Environment, class FirstArgument, void(*func)(const Environment *, FirstArgument)>
-using ConstPointerCaller1 = BindFirstOpaque<Function2<const Environment *, FirstArgument, void, func>>;
+using ConstPointerCaller1 = ConstPointerCallerN<Environment, void(FirstArgument), func>;
 
-/// \brief Forms a Callback from a free function which takes no arguments.
 template<void(*func)()>
-class FreeCaller : public BindFirstOpaque<Caller0To1<Function0<void, func>>> {
-public:
-	FreeCaller() : BindFirstOpaque<Caller0To1<Function0<void, func>>>(0) {
-	}
-};
+using FreeCaller = FreeCallerN<void(), func>;
 
-/// \brief Forms a Callback from a free function which takes a single argument.
 template<class FirstArgument, void(*func)(FirstArgument)>
-class FreeCaller1 : public BindFirstOpaque<Caller1To2<Function1<FirstArgument, void, func>>> {
-public:
-	FreeCaller1() : BindFirstOpaque<Caller1To2<Function1<FirstArgument, void, func>>>(0) {
-	}
-};
-
-
-/// \brief Constructs a Callback from a non-const \p functor with zero arguments.
-///
-/// \param Functor Must define \c operator()().
-template<typename Functor>
-inline Callback makeCallback( Functor& functor ){
-	return Callback( MemberCaller<Functor, &Functor::operator()>( functor ) );
-}
-
-/// \brief  Constructs a Callback from a const \p functor with zero arguments.
-///
-/// \param Functor Must define const \c operator()().
-template<typename Functor>
-inline Callback makeCallback( const Functor& functor ){
-	return Callback( ConstMemberCaller<Functor, &Functor::operator()>( functor ) );
-}
-
-/// \brief  Constructs a Callback1 from a non-const \p functor with one argument.
-///
-/// \param Functor Must define \c first_argument_type and \c operator()(first_argument_type).
-template<typename Functor>
-inline Callback1<get_argument<Functor, 0>> makeCallback1(Functor &functor) {
-	typedef get_argument<Functor, 0> FirstArgument;
-	return Callback1<FirstArgument>( MemberCaller1<Functor, FirstArgument, &Functor::operator()>( functor ) );
-}
-
-/// \brief  Constructs a Callback1 from a const \p functor with one argument.
-///
-/// \param Functor Must define \c first_argument_type and const \c operator()(first_argument_type).
-template<typename Functor>
-inline Callback1<get_argument<Functor, 0>> makeCallback1(const Functor &functor) {
-	typedef get_argument<Functor, 0> FirstArgument;
-	return Callback1<FirstArgument>( ConstMemberCaller1<Functor, FirstArgument, &Functor::operator()>( functor ) );
-}
-
+using FreeCaller1 = FreeCallerN<void(FirstArgument), func>;
 
 typedef Callback1<bool> BoolImportCallback;
 typedef Callback1<const BoolImportCallback&> BoolExportCallback;
@@ -414,5 +395,4 @@ typedef Callback1<const StringImportCallback&> StringExportCallback;
 typedef Callback1<std::size_t> SizeImportCallback;
 typedef Callback1<const SizeImportCallback&> SizeExportCallback;
 
-
 #endif
diff --git a/libs/generic/callbackfwd.h b/libs/generic/callbackfwd.h
deleted file mode 100644
index 48c01d39..00000000
--- a/libs/generic/callbackfwd.h
+++ /dev/null
@@ -1,18 +0,0 @@
-
-#if !defined( INCLUDED_CALLBACKFWD_H )
-#define INCLUDED_CALLBACKFWD_H
-
-template<typename Return>
-class Callback0;
-typedef Callback0<void> Callback;
-
-template<typename FirstArgument, typename Result = void>
-class Callback1;
-
-template<typename FirstArgument, typename SecondArgument, typename Result = void>
-class Callback2;
-
-template<typename FirstArgument, typename SecondArgument, typename ThirdArgument, typename Result = void>
-class Callback3;
-
-#endif
diff --git a/libs/generic/functional.h b/libs/generic/functional.h
index 8843e363..ecbf6c7d 100644
--- a/libs/generic/functional.h
+++ b/libs/generic/functional.h
@@ -184,6 +184,8 @@ public:
 template<class Functor>
 using FunctorInvoke = FunctorNInvoke<Functor, get_func<Functor>>;
 
+// todo: inline
+
 template<class Object, class R, R(Object::*member)()>
 using Member = typename MemberN<Object, R()>::template instance<member>;
 
@@ -223,30 +225,4 @@ using Function3 = typename FunctionN<R(A1, A2, A3)>::template instance<func>;
 template<class A1, class A2, class A3, class A4, class R, R(*func)(A1, A2, A3, A4)>
 using Function4 = typename FunctionN<R(A1, A2, A3, A4)>::template instance<func>;
 
-template<class Caller, class FirstArgument = void *>
-using Caller0To1 = CallerShiftFirst<Caller, get_result_type<Caller>(
-        FirstArgument
-)>;
-
-template<class Caller, class FirstArgument = void *>
-using Caller1To2 = CallerShiftFirst<Caller, get_result_type<Caller>(
-        FirstArgument,
-        get_argument<Caller, 0>
-)>;
-
-template<class Caller, class FirstArgument = void *>
-using Caller2To3 = CallerShiftFirst<Caller, get_result_type<Caller>(
-        FirstArgument,
-        get_argument<Caller, 0>,
-        get_argument<Caller, 1>
-)>;
-
-template<class Caller, class FirstArgument = void *>
-using Caller3To4 = CallerShiftFirst<Caller, get_result_type<Caller>(
-        FirstArgument,
-        get_argument<Caller, 0>,
-        get_argument<Caller, 1>,
-        get_argument<Caller, 2>
-)>;
-
 #endif
diff --git a/libs/gtkutil/button.h b/libs/gtkutil/button.h
index b7aa4127..cec03b2f 100644
--- a/libs/gtkutil/button.h
+++ b/libs/gtkutil/button.h
@@ -23,7 +23,7 @@
 #define INCLUDED_GTKUTIL_BUTTON_H
 
 #include <uilib/uilib.h>
-#include "generic/callbackfwd.h"
+#include "generic/callback.h"
 
 typedef int gint;
 typedef gint gboolean;
diff --git a/libs/gtkutil/menu.h b/libs/gtkutil/menu.h
index 9b040450..5d361f29 100644
--- a/libs/gtkutil/menu.h
+++ b/libs/gtkutil/menu.h
@@ -23,7 +23,7 @@
 #define INCLUDED_GTKUTIL_MENU_H
 
 #include <uilib/uilib.h>
-#include "generic/callbackfwd.h"
+#include "generic/callback.h"
 
 typedef int gint;
 typedef gint gboolean;
diff --git a/libs/gtkutil/toolbar.h b/libs/gtkutil/toolbar.h
index 66f38805..60515019 100644
--- a/libs/gtkutil/toolbar.h
+++ b/libs/gtkutil/toolbar.h
@@ -23,7 +23,7 @@
 #define INCLUDED_GTKUTIL_TOOLBAR_H
 
 #include <uilib/uilib.h>
-#include "generic/callbackfwd.h"
+#include "generic/callback.h"
 
 class Command;
 class Toggle;
diff --git a/radiant/brushmanip.h b/radiant/brushmanip.h
index 8795bf4e..0654fd89 100644
--- a/radiant/brushmanip.h
+++ b/radiant/brushmanip.h
@@ -25,7 +25,7 @@
 #include <cstddef>
 #include <uilib/uilib.h>
 #include "string/stringfwd.h"
-#include "generic/callbackfwd.h"
+#include "generic/callback.h"
 
 enum EBrushPrefab
 {
diff --git a/radiant/selection.h b/radiant/selection.h
index 1082c002..b8f4fcfb 100644
--- a/radiant/selection.h
+++ b/radiant/selection.h
@@ -23,7 +23,7 @@
 #define INCLUDED_SELECTION_H
 
 #include "windowobserver.h"
-#include "generic/callbackfwd.h"
+#include "generic/callback.h"
 
 struct rect_t
 {
diff --git a/radiant/textures.h b/radiant/textures.h
index 297ebc99..cdd1a9b1 100644
--- a/radiant/textures.h
+++ b/radiant/textures.h
@@ -22,7 +22,7 @@
 #if !defined ( INCLUDED_TEXTURES_H )
 #define INCLUDED_TEXTURES_H
 
-#include "generic/callbackfwd.h"
+#include "generic/callback.h"
 
 void Textures_Realise();
 void Textures_Unrealise();
diff --git a/radiant/texwindow.h b/radiant/texwindow.h
index 15ec907c..9a153c44 100644
--- a/radiant/texwindow.h
+++ b/radiant/texwindow.h
@@ -24,7 +24,7 @@
 
 #include <uilib/uilib.h>
 #include "math/vector.h"
-#include "generic/callbackfwd.h"
+#include "generic/callback.h"
 #include "signal/signalfwd.h"
 #include "xml/xmltextags.h"
 
@@ -44,8 +44,6 @@ void TextureBrowser_Construct();
 void TextureBrowser_Destroy();
 
 typedef Callback1<const char*> StringImportCallback;
-template<typename FirstArgument, void( *func ) (FirstArgument)>
-class FreeCaller1;
 
 extern ui::Widget g_page_textures;
 void TextureBrowser_exportTitle( const StringImportCallback& importer );