Fix MSYS2 issues

[xonotic/netradiant.git] / libs / generic / functional.h

diff --git a/libs/generic/functional.h b/libs/generic/functional.h
index ca1d86307f549d388913fbbd7bc358a132b0cfa5..940d4e7fd0af09b448faa099f07ebd8c8e6a904b 100644 (file)
--- a/libs/generic/functional.h
+++ b/libs/generic/functional.h
@@ -1,318 +1,288 @@
 
-#if !defined(INCLUDED_FUNCTIONAL_H)
+#if !defined( INCLUDED_FUNCTIONAL_H )
 #define INCLUDED_FUNCTIONAL_H
 
-template<typename Object, typename R, R (Object::*member)()>
+template<typename Object, typename R, R( Object::*member ) ( )>
 class Member
 {
 public:
-  typedef Object& first_argument_type;
-  typedef R result_type;
-  static result_type call(first_argument_type object)
-  {
-    return (object.*member)();
-  }
+typedef Object& first_argument_type;
+typedef R result_type;
+static result_type call( first_argument_type object ){
+       return ( object.*member )();
+}
 };
 
-template<typename Object, typename R, R (Object::*member)() const>
+template<typename Object, typename R, R( Object::*member ) ( ) const>
 class ConstMember
 {
 public:
-  typedef const Object& first_argument_type;
-  typedef R result_type;
-  static result_type call(first_argument_type object)
-  {
-    return (object.*member)();
-  }
+typedef const Object& first_argument_type;
+typedef R result_type;
+static result_type call( first_argument_type object ){
+       return ( object.*member )();
+}
 };
 
-template<typename Object, typename A1, typename R, R (Object::*member)(A1)>
+template<typename Object, typename A1, typename R, R( Object::*member ) (A1)>
 class Member1
 {
 public:
-  typedef Object& first_argument_type;
-  typedef A1 second_argument_type;
-  typedef R result_type;
-  static result_type call(first_argument_type object, second_argument_type a1)
-  {
-    return (object.*member)(a1);
-  }
+typedef Object& first_argument_type;
+typedef A1 second_argument_type;
+typedef R result_type;
+static result_type call( first_argument_type object, second_argument_type a1 ){
+       return ( object.*member )( a1 );
+}
 };
 
-template<typename Object, typename A1, typename R, R (Object::*member)(A1) const>
+template<typename Object, typename A1, typename R, R( Object::*member ) (A1) const>
 class ConstMember1
 {
 public:
-  typedef const Object& first_argument_type;
-  typedef A1 second_argument_type;
-  typedef R result_type;
-  static result_type call(first_argument_type object, second_argument_type a1)
-  {
-    return (object.*member)(a1);
-  }
+typedef const Object& first_argument_type;
+typedef A1 second_argument_type;
+typedef R result_type;
+static result_type call( first_argument_type object, second_argument_type a1 ){
+       return ( object.*member )( a1 );
+}
 };
 
-template<typename Object, typename A2, typename A3, typename R, R (Object::*member)(A2, A3)>
+template<typename Object, typename A2, typename A3, typename R, R( Object::*member ) ( A2, A3 )>
 class Member2
 {
 public:
-  typedef Object& first_argument_type;
-  typedef A2 second_argument_type;
-  typedef A3 third_argument_type;
-  typedef R result_type;
-  static result_type call(first_argument_type object, second_argument_type a2, third_argument_type a3)
-  {
-    return (object.*member)(a2, a3);
-  }
+typedef Object& first_argument_type;
+typedef A2 second_argument_type;
+typedef A3 third_argument_type;
+typedef R result_type;
+static result_type call( first_argument_type object, second_argument_type a2, third_argument_type a3 ){
+       return ( object.*member )( a2, a3 );
+}
 };
 
-template<typename Object, typename A2, typename A3, typename R, R (Object::*member)(A2, A3) const>
+template<typename Object, typename A2, typename A3, typename R, R( Object::*member ) ( A2, A3 ) const>
 class ConstMember2
 {
 public:
-  typedef const Object& first_argument_type;
-  typedef A2 second_argument_type;
-  typedef A3 third_argument_type;
-  typedef R result_type;
-  static result_type call(first_argument_type object, second_argument_type a2, third_argument_type a3)
-  {
-    return (object.*member)(a2, a3);
-  }
+typedef const Object& first_argument_type;
+typedef A2 second_argument_type;
+typedef A3 third_argument_type;
+typedef R result_type;
+static result_type call( first_argument_type object, second_argument_type a2, third_argument_type a3 ){
+       return ( object.*member )( a2, a3 );
+}
 };
 
-template<typename Object, typename A2, typename A3, typename A4, typename R, R (Object::*member)(A2, A3, A4)>
+template<typename Object, typename A2, typename A3, typename A4, typename R, R( Object::*member ) ( A2, A3, A4 )>
 class Member3
 {
 public:
-  typedef Object& first_argument_type;
-  typedef A2 second_argument_type;
-  typedef A3 third_argument_type;
-  typedef A4 fourth_argument_type;
-  typedef R result_type;
-  static result_type call(first_argument_type object, second_argument_type a2, third_argument_type a3, fourth_argument_type a4)
-  {
-    return (object.*member)(a2, a3, a4);
-  }
+typedef Object& first_argument_type;
+typedef A2 second_argument_type;
+typedef A3 third_argument_type;
+typedef A4 fourth_argument_type;
+typedef R result_type;
+static result_type call( first_argument_type object, second_argument_type a2, third_argument_type a3, fourth_argument_type a4 ){
+       return ( object.*member )( a2, a3, a4 );
+}
 };
 
-template<typename Object, typename A2, typename A3, typename A4, typename R, R (Object::*member)(A2, A3, A4) const>
+template<typename Object, typename A2, typename A3, typename A4, typename R, R( Object::*member ) ( A2, A3, A4 ) const>
 class ConstMember3
 {
 public:
-  typedef const Object& first_argument_type;
-  typedef A2 second_argument_type;
-  typedef A3 third_argument_type;
-  typedef A4 fourth_argument_type;
-  typedef R result_type;
-  static result_type call(first_argument_type object, second_argument_type a2, third_argument_type a3, fourth_argument_type a4)
-  {
-    return (object.*member)(a2, a3, a4);
-  }
+typedef const Object& first_argument_type;
+typedef A2 second_argument_type;
+typedef A3 third_argument_type;
+typedef A4 fourth_argument_type;
+typedef R result_type;
+static result_type call( first_argument_type object, second_argument_type a2, third_argument_type a3, fourth_argument_type a4 ){
+       return ( object.*member )( a2, a3, a4 );
+}
 };
 
-template<typename R, R (*func)()> 
+template<typename R, R( *func ) ( )>
 class Function0
 {
 public:
-  typedef R result_type;
-  static result_type call()
-  {
-    return (func)();
-  }
+typedef R result_type;
+static result_type call(){
+       return (func)( );
+}
 };
 
-template<typename A1, typename R, R (*func)(A1)> 
+template<typename A1, typename R, R( *func ) (A1)>
 class Function1
 {
 public:
-  typedef A1 first_argument_type;
-  typedef R result_type;
-  static result_type call(first_argument_type a1)
-  {
-    return (func)(a1);
-  }
+typedef A1 first_argument_type;
+typedef R result_type;
+static result_type call( first_argument_type a1 ){
+       return (func)( a1 );
+}
 };
 
-template<typename A1, typename A2, typename R, R (*func)(A1, A2)> 
+template<typename A1, typename A2, typename R, R( *func ) ( A1, A2 )>
 class Function2
 {
 public:
-  typedef A1 first_argument_type;
-  typedef A2 second_argument_type;
-  typedef R result_type;
-  static result_type call(first_argument_type a1, second_argument_type a2)
-  {
-    return (func)(a1, a2);
-  }
+typedef A1 first_argument_type;
+typedef A2 second_argument_type;
+typedef R result_type;
+static result_type call( first_argument_type a1, second_argument_type a2 ){
+       return (func)( a1, a2 );
+}
 };
 
-template<typename A1, typename A2, typename A3, typename R, R (*func)(A1, A2, A3)> 
+template<typename A1, typename A2, typename A3, typename R, R( *func ) ( A1, A2, A3 )>
 class Function3
 {
 public:
-  typedef A1 first_argument_type;
-  typedef A2 second_argument_type;
-  typedef A3 third_argument_type;
-  typedef R result_type;
-  static result_type call(first_argument_type a1, second_argument_type a2, third_argument_type a3)
-  {
-    return (func)(a1, a2, a3);
-  }
+typedef A1 first_argument_type;
+typedef A2 second_argument_type;
+typedef A3 third_argument_type;
+typedef R result_type;
+static result_type call( first_argument_type a1, second_argument_type a2, third_argument_type a3 ){
+       return (func)( a1, a2, a3 );
+}
 };
 
-template<typename A1, typename A2, typename A3, typename A4, typename R, R (*func)(A1, A2, A3, A4)> 
+template<typename A1, typename A2, typename A3, typename A4, typename R, R( *func ) ( A1, A2, A3, A4 )>
 class Function4
 {
 public:
-  typedef A1 first_argument_type;
-  typedef A2 second_argument_type;
-  typedef A3 third_argument_type;
-  typedef A4 fourth_argument_type;
-  typedef R result_type;
-  static result_type call(first_argument_type a1, second_argument_type a2, third_argument_type a3, fourth_argument_type a4)
-  {
-    return (func)(a1, a2, a3, a4);
-  }
+typedef A1 first_argument_type;
+typedef A2 second_argument_type;
+typedef A3 third_argument_type;
+typedef A4 fourth_argument_type;
+typedef R result_type;
+static result_type call( first_argument_type a1, second_argument_type a2, third_argument_type a3, fourth_argument_type a4 ){
+       return (func)( a1, a2, a3, a4 );
+}
 };
 
-template<typename Caller, typename FirstArgument = void*> 
+template<typename Caller, typename FirstArgument = void*>
 class Caller0To1
 {
 public:
-  typedef FirstArgument first_argument_type;
-  typedef typename Caller::result_type result_type;
-  static result_type call(first_argument_type)
-  {
-    return Caller::call();
-  }
+typedef FirstArgument first_argument_type;
+typedef typename Caller::result_type result_type;
+static result_type call( first_argument_type ){
+       return Caller::call();
+}
 };
 
-template<typename Caller, typename FirstArgument = void*> 
+template<typename Caller, typename FirstArgument = void*>
 class Caller1To2
 {
 public:
-  typedef FirstArgument first_argument_type;
-  typedef typename Caller::first_argument_type second_argument_type;
-  typedef typename Caller::result_type result_type;
-  static result_type call(first_argument_type, second_argument_type a2)
-  {
-    return Caller::call(a2);
-  }
+typedef FirstArgument first_argument_type;
+typedef typename Caller::first_argument_type second_argument_type;
+typedef typename Caller::result_type result_type;
+static result_type call( first_argument_type, second_argument_type a2 ){
+       return Caller::call( a2 );
+}
 };
 
-template<typename Caller, typename FirstArgument = void*> 
+template<typename Caller, typename FirstArgument = void*>
 class Caller2To3
 {
 public:
-  typedef FirstArgument first_argument_type;
-  typedef typename Caller::first_argument_type second_argument_type;
-  typedef typename Caller::second_argument_type third_argument_type;
-  typedef typename Caller::result_type result_type;
-  static result_type call(first_argument_type, second_argument_type a2, third_argument_type a3)
-  {
-    return Caller::call(a2, a3);
-  }
+typedef FirstArgument first_argument_type;
+typedef typename Caller::first_argument_type second_argument_type;
+typedef typename Caller::second_argument_type third_argument_type;
+typedef typename Caller::result_type result_type;
+static result_type call( first_argument_type, second_argument_type a2, third_argument_type a3 ){
+       return Caller::call( a2, a3 );
+}
 };
 
-template<typename Caller, typename FirstArgument = void*> 
+template<typename Caller, typename FirstArgument = void*>
 class Caller3To4
 {
 public:
-  typedef FirstArgument first_argument_type;
-  typedef typename Caller::first_argument_type second_argument_type;
-  typedef typename Caller::second_argument_type third_argument_type;
-  typedef typename Caller::third_argument_type fourth_argument_type;
-  typedef typename Caller::result_type result_type;
-  static result_type call(first_argument_type, second_argument_type a2, third_argument_type a3, fourth_argument_type a4)
-  {
-    return Caller::call(a2, a3, a4);
-  }
+typedef FirstArgument first_argument_type;
+typedef typename Caller::first_argument_type second_argument_type;
+typedef typename Caller::second_argument_type third_argument_type;
+typedef typename Caller::third_argument_type fourth_argument_type;
+typedef typename Caller::result_type result_type;
+static result_type call( first_argument_type, second_argument_type a2, third_argument_type a3, fourth_argument_type a4 ){
+       return Caller::call( a2, a3, a4 );
+}
 };
 
 template<typename Functor>
 class FunctorInvoke
 {
 public:
-  typedef typename Functor::result_type result_type;
-  inline result_type operator()(Functor functor)
-  {
-    return functor();
-  }
+typedef typename Functor::result_type result_type;
+inline result_type operator()( Functor functor ){
+       return functor();
+}
 };
 
 template<typename Functor>
 class Functor1Invoke
 {
-  typename Functor::first_argument_type a1;
+typename Functor::first_argument_type a1;
 public:
-  typedef typename Functor::first_argument_type first_argument_type;
-  typedef typename Functor::result_type result_type;
-  Functor1Invoke(first_argument_type a1) : a1(a1)
-  {
-  }
-  inline result_type operator()(Functor functor)
-  {
-    return functor(a1);
-  }
+typedef typename Functor::first_argument_type first_argument_type;
+typedef typename Functor::result_type result_type;
+Functor1Invoke( first_argument_type a1 ) : a1( a1 ){
+}
+inline result_type operator()( Functor functor ){
+       return functor( a1 );
+}
 };
 
 template<typename Functor>
 class Functor2Invoke
 {
-  typename Functor::first_argument_type a1;
-  typename Functor::second_argument_type a2;
+typename Functor::first_argument_type a1;
+typename Functor::second_argument_type a2;
 public:
-  typedef typename Functor::first_argument_type first_argument_type;
-  typedef typename Functor::second_argument_type second_argument_type;
-  typedef typename Functor::result_type result_type;
-  Functor2Invoke(first_argument_type a1, second_argument_type a2)
-    : a1(a1), a2(a2)
-  {
-  }
-  inline result_type operator()(Functor functor)
-  {
-    return functor(a1, a2);
-  }
+typedef typename Functor::first_argument_type first_argument_type;
+typedef typename Functor::second_argument_type second_argument_type;
+typedef typename Functor::result_type result_type;
+Functor2Invoke( first_argument_type a1, second_argument_type a2 )
+       : a1( a1 ), a2( a2 ){
+}
+inline result_type operator()( Functor functor ){
+       return functor( a1, a2 );
+}
 };
 
 template<typename Functor>
 class Functor3Invoke
 {
-  typename Functor::first_argument_type a1;
-  typename Functor::second_argument_type a2;
-  typename Functor::third_argument_type a3;
+typename Functor::first_argument_type a1;
+typename Functor::second_argument_type a2;
+typename Functor::third_argument_type a3;
 public:
-  typedef typename Functor::first_argument_type first_argument_type;
-  typedef typename Functor::second_argument_type second_argument_type;
-  typedef typename Functor::third_argument_type third_argument_type;
-  typedef typename Functor::result_type result_type;
-  Functor3Invoke(first_argument_type a1, second_argument_type a2, third_argument_type a3)
-    : a1(a1), a2(a2), a3(a3)
-  {
-  }
-  inline result_type operator()(Functor functor)
-  {
-    return functor(a1, a2, a3);
-  }
+typedef typename Functor::first_argument_type first_argument_type;
+typedef typename Functor::second_argument_type second_argument_type;
+typedef typename Functor::third_argument_type third_argument_type;
+typedef typename Functor::result_type result_type;
+Functor3Invoke( first_argument_type a1, second_argument_type a2, third_argument_type a3 )
+       : a1( a1 ), a2( a2 ), a3( a3 ){
+}
+inline result_type operator()( Functor functor ){
+       return functor( a1, a2, a3 );
+}
 };
 
-template<typename Type, typename Other, typename True, typename False>
+template<typename Other, typename True, typename False, typename Type>
 class TypeEqual
 {
-  template<typename Matched>
-  class Match
-  {
-  public:
-    typedef False type;
-  };
-  template<>
-  class Match<Other>
-  {
-  public:
-    typedef True type;
-  };
 public:
-  typedef typename Match<Type>::type type;
+typedef False type;
+};
+template<typename Other, typename True, typename False>
+class TypeEqual<Other, True, False, Other>
+{
+public:
+typedef True type;
 };