Initial Commit

Plugins/GameLiftServerSDK/ThirdParty/concurrentqueue/benchmarks/dlib/member_function_pointer/make_mfp.h

@@ -0,0 +1,179 @@
+// Copyright (C) 2011  Davis E. King (davis@dlib.net)
+// License: Boost Software License   See LICENSE.txt for the full license.
+#ifndef DLIB_MAKE_MFp_H_
+#define DLIB_MAKE_MFp_H_
+
+#include "member_function_pointer_kernel_1.h"
+#include "make_mfp_abstract.h"
+
+namespace dlib
+{
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename T
+        >
+    member_function_pointer<> make_mfp (
+        T& object,
+        void (T::*cb)()
+    )
+    {
+        member_function_pointer<> temp;
+        temp.set(object, cb);
+        return temp;
+    }
+
+    template <
+        typename T
+        >
+    member_function_pointer<> make_mfp (
+        const T& object,
+        void (T::*cb)()const
+    )
+    {
+        member_function_pointer<> temp;
+        temp.set(object, cb);
+        return temp;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename T,
+        typename A1
+        >
+    member_function_pointer<A1> make_mfp (
+        T& object,
+        void (T::*cb)(A1)
+    )
+    {
+        member_function_pointer<A1> temp;
+        temp.set(object, cb);
+        return temp;
+    }
+
+    template <
+        typename T,
+        typename A1
+        >
+    member_function_pointer<A1> make_mfp (
+        const T& object,
+        void (T::*cb)(A1)const
+    )
+    {
+        member_function_pointer<A1> temp;
+        temp.set(object, cb);
+        return temp;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename T,
+        typename A1,
+        typename A2
+        >
+    member_function_pointer<A1,A2> make_mfp (
+        T& object,
+        void (T::*cb)(A1,A2)
+    )
+    {
+        member_function_pointer<A1,A2> temp;
+        temp.set(object, cb);
+        return temp;
+    }
+
+    template <
+        typename T,
+        typename A1,
+        typename A2
+        >
+    member_function_pointer<A1,A2> make_mfp (
+        const T& object,
+        void (T::*cb)(A1,A2)const
+    )
+    {
+        member_function_pointer<A1,A2> temp;
+        temp.set(object, cb);
+        return temp;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename T,
+        typename A1,
+        typename A2,
+        typename A3
+        >
+    member_function_pointer<A1,A2,A3> make_mfp (
+        T& object,
+        void (T::*cb)(A1,A2,A3)
+    )
+    {
+        member_function_pointer<A1,A2,A3> temp;
+        temp.set(object, cb);
+        return temp;
+    }
+
+    template <
+        typename T,
+        typename A1,
+        typename A2,
+        typename A3
+        >
+    member_function_pointer<A1,A2,A3> make_mfp (
+        const T& object,
+        void (T::*cb)(A1,A2,A3)const
+    )
+    {
+        member_function_pointer<A1,A2,A3> temp;
+        temp.set(object, cb);
+        return temp;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename T,
+        typename A1,
+        typename A2,
+        typename A3,
+        typename A4
+        >
+    member_function_pointer<A1,A2,A3,A4> make_mfp (
+        T& object,
+        void (T::*cb)(A1,A2,A3,A4)
+    )
+    {
+        member_function_pointer<A1,A2,A3,A4> temp;
+        temp.set(object, cb);
+        return temp;
+    }
+
+    template <
+        typename T,
+        typename A1,
+        typename A2,
+        typename A3,
+        typename A4
+        >
+    member_function_pointer<A1,A2,A3,A4> make_mfp (
+        const T& object,
+        void (T::*cb)(A1,A2,A3,A4)const
+    )
+    {
+        member_function_pointer<A1,A2,A3,A4> temp;
+        temp.set(object, cb);
+        return temp;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+}
+
+#endif // DLIB_MAKE_MFp_H_
+
+
+

Plugins/GameLiftServerSDK/ThirdParty/concurrentqueue/benchmarks/dlib/member_function_pointer/make_mfp_abstract.h

@@ -0,0 +1,207 @@
+// Copyright (C) 2011  Davis E. King (davis@dlib.net)
+// License: Boost Software License   See LICENSE.txt for the full license.
+#undef DLIB_MAKE_MFp_ABSTRACT_
+#ifdef DLIB_MAKE_MFp_ABSTRACT_
+
+#include "member_function_pointer_kernel_abstract.h"
+
+namespace dlib
+{
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename T
+        >
+    member_function_pointer<> make_mfp (
+        T& object,
+        void (T::*cb)()
+    );
+    /*!
+        requires
+            - cb == a valid member function pointer for class T
+        ensures
+            - returns a member function pointer object MFP such that:
+                - MFP.is_set() == true
+                - calls to MFP() will call (object.*cb)()
+    !*/
+
+    template <
+        typename T
+        >
+    member_function_pointer<> make_mfp (
+        const T& object,
+        void (T::*cb)()const
+    );
+    /*!
+        requires
+            - cb == a valid member function pointer for class T
+        ensures
+            - returns a member function pointer object MFP such that:
+                - MFP.is_set() == true
+                - calls to MFP() will call (object.*cb)()
+    !*/
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename T,
+        typename A1
+        >
+    member_function_pointer<A1> make_mfp (
+        T& object,
+        void (T::*cb)(A1 a1)
+    );
+    /*!
+        requires
+            - cb == a valid member function pointer for class T
+        ensures
+            - returns a member function pointer object MFP such that:
+                - MFP.is_set() == true
+                - calls to MFP(a1) will call (object.*cb)(a1)
+    !*/
+
+    template <
+        typename T,
+        typename A1
+        >
+    member_function_pointer<A1> make_mfp (
+        const T& object,
+        void (T::*cb)(A1 a1)const
+    );
+    /*!
+        requires
+            - cb == a valid member function pointer for class T
+        ensures
+            - returns a member function pointer object MFP such that:
+                - MFP.is_set() == true
+                - calls to MFP(a1) will call (object.*cb)(a1)
+    !*/
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename T,
+        typename A1,
+        typename A2
+        >
+    member_function_pointer<A1,A2> make_mfp (
+        T& object,
+        void (T::*cb)(A1 a1, A2 a2)
+    );
+    /*!
+        requires
+            - cb == a valid member function pointer for class T
+        ensures
+            - returns a member function pointer object MFP such that:
+                - MFP.is_set() == true
+                - calls to MFP(a1,a2) will call (object.*cb)(a1,a2)
+    !*/
+
+    template <
+        typename T,
+        typename A1,
+        typename A2
+        >
+    member_function_pointer<A1,A2> make_mfp (
+        const T& object,
+        void (T::*cb)(A1 a1, A2 a2)const
+    );
+    /*!
+        requires
+            - cb == a valid member function pointer for class T
+        ensures
+            - returns a member function pointer object MFP such that:
+                - MFP.is_set() == true
+                - calls to MFP(a1,a2) will call (object.*cb)(a1,a2)
+    !*/
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename T,
+        typename A1,
+        typename A2,
+        typename A3
+        >
+    member_function_pointer<A1,A2,A3> make_mfp (
+        T& object,
+        void (T::*cb)(A1 a1, A2 a2, A3 a3)
+    );
+    /*!
+        requires
+            - cb == a valid member function pointer for class T
+        ensures
+            - returns a member function pointer object MFP such that:
+                - MFP.is_set() == true
+                - calls to MFP(a1,a2,a3) will call (object.*cb)(a1,a2,a3)
+    !*/
+
+    template <
+        typename T,
+        typename A1,
+        typename A2,
+        typename A3
+        >
+    member_function_pointer<A1,A2,A3> make_mfp (
+        const T& object,
+        void (T::*cb)(A1 a1, A2 a2, A3 a3)const
+    );
+    /*!
+        requires
+            - cb == a valid member function pointer for class T
+        ensures
+            - returns a member function pointer object MFP such that:
+                - MFP.is_set() == true
+                - calls to MFP(a1,a2,a3) will call (object.*cb)(a1,a2,a3)
+    !*/
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename T,
+        typename A1,
+        typename A2,
+        typename A3,
+        typename A4
+        >
+    member_function_pointer<A1,A2,A3,A4> make_mfp (
+        T& object,
+        void (T::*cb)(A1 a1, A2 a2, A3 a3, A4 a4)
+    );
+    /*!
+        requires
+            - cb == a valid member function pointer for class T
+        ensures
+            - returns a member function pointer object MFP such that:
+                - MFP.is_set() == true
+                - calls to MFP(a1,a2,a3,a4) will call (object.*cb)(a1,a2,a3,a4)
+    !*/
+
+    template <
+        typename T,
+        typename A1,
+        typename A2,
+        typename A3,
+        typename A4
+        >
+    member_function_pointer<A1,A2,A3,A4> make_mfp (
+        const T& object,
+        void (T::*cb)(A1 a1, A2 a2, A3 a3, A4 a4)const
+    );
+    /*!
+        requires
+            - cb == a valid member function pointer for class T
+        ensures
+            - returns a member function pointer object MFP such that:
+                - MFP.is_set() == true
+                - calls to MFP(a1,a2,a3,a4) will call (object.*cb)(a1,a2,a3,a4)
+    !*/
+
+// ----------------------------------------------------------------------------------------
+
+}
+
+#endif // DLIB_MAKE_MFp_ABSTRACT_
+
+

Plugins/GameLiftServerSDK/ThirdParty/concurrentqueue/benchmarks/dlib/member_function_pointer/member_function_pointer_kernel_1.h

@@ -0,0 +1,509 @@
+// Copyright (C) 2005  Davis E. King (davis@dlib.net)
+// License: Boost Software License   See LICENSE.txt for the full license.
+#ifndef DLIB_MEMBER_FUNCTION_POINTER_KERNEl_1_
+#define DLIB_MEMBER_FUNCTION_POINTER_KERNEl_1_
+
+#include "../algs.h"
+#include "member_function_pointer_kernel_abstract.h"
+#include "../enable_if.h"
+#include <new>
+
+namespace dlib
+{
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename PARAM1 = void,
+        typename PARAM2 = void,
+        typename PARAM3 = void,
+        typename PARAM4 = void
+        >
+    class member_function_pointer;
+
+// ----------------------------------------------------------------------------------------
+
+#define DLIB_MFP_SC DLIB_ASSERT(cb != 0,                                \
+                   "\tvoid member_function_pointer::set"                \
+                   << "\n\tthe member function pointer can't be null"   \
+                   << "\n\tthis: " << this   );
+
+
+#define DLIB_MFP_OC DLIB_ASSERT(this->is_set() == true ,                            \
+                   "\tvoid member_function_pointer::operator()"                     \
+                   << "\n\tYou must call set() before you can use this function"    \
+                   << "\n\tthis: " << this);
+
+// ----------------------------------------------------------------------------------------
+
+    template <unsigned long num_args>
+    class mfp_kernel_1_base_class
+    {
+        /*
+            All member function pointer classes inherit from this class.  This
+            is where most of the things in a member function pointer are defined.
+
+            The reason for the num_args template argument to this class is to prevent
+            any sort of implicit casting between derived member function pointer classes
+            that take different numbers of arguments.
+        */
+    protected:
+        enum mfp_type { mfp_nonconst, mfp_const, mfp_null};
+
+        class mp_base_base
+        {
+        public:
+            mp_base_base(void* ptr, mfp_type type_) : o(ptr),type(type_) {}
+            virtual ~mp_base_base(){}
+            virtual void clone(void* ptr) const = 0;
+            virtual bool is_same (const mp_base_base* item) const = 0;
+            bool is_set () const { return o!=0; }
+
+            void* const o;
+            const mfp_type type;
+        };
+
+        template <typename T>
+        class mp_null : public mp_base_base 
+        {
+        public:
+            typedef void (T::*mfp_pointer_type)() ;
+
+            mp_null (void* , mfp_pointer_type ) : mp_base_base(0,mfp_null), callback(0) {}
+            mp_null () : mp_base_base(0,mfp_null), callback(0) {}
+
+            const mfp_pointer_type callback;
+        };
+
+        template <typename mp_impl>
+        class mp_impl_T : public mp_impl 
+        {
+            /*
+                This class supplies the implementations clone() and is_same() for any
+                classes that inherit from mp_base_base.  It does this in a very
+                roundabout way...
+            */
+               
+        public:
+            typedef typename mp_impl::mfp_pointer_type mfp_pointer_type;
+
+            mp_impl_T() : mp_impl(0,0) {}
+            mp_impl_T(void* ptr, mfp_pointer_type cb) : mp_impl(ptr,cb) {}
+
+            template <unsigned long mem_size>
+            void safe_clone(stack_based_memory_block<mem_size>& buf)
+            {
+                // This is here just to validate the assumption that our block of memory we have made
+                // in mp_memory is the right size to store the data for this object.  If you
+                // get a compiler error on this line then email me :)
+                COMPILE_TIME_ASSERT(sizeof(mp_impl_T) <= mem_size);
+                clone(buf.get());
+            }
+
+            void clone   (void* ptr) const  { new(ptr) mp_impl_T(this->o,this->callback); }
+            bool is_same (const mp_base_base* item) const 
+            {
+                if (item->o == 0 && this->o == 0)
+                {
+                    return true;
+                }
+                else if (item->o == this->o && this->type == item->type)
+                {
+                    const mp_impl* i = reinterpret_cast<const mp_impl*>(item);
+                    return (i->callback == this->callback);
+                }
+                return false;
+            }
+        };
+
+        // MSVC with the /vms option, we get C2287 since the dummy class requires virtual
+        // inheritance. Adding the __virtual_inheritance specifier explicitly fixes the issue,
+        // but then Clang-CL no longer accepts it.
+        #if defined(_MSC_VER) && !defined(__clang__)
+            #define DLIB_MSVC_INHERITANCE_VIRTUAL __virtual_inheritance
+        #else
+            #define DLIB_MSVC_INHERITANCE_VIRTUAL
+        #endif
+
+        struct dummy_base { virtual void nonnull() {}; virtual ~dummy_base(){}; int a; };
+        struct DLIB_MSVC_INHERITANCE_VIRTUAL dummy : virtual public dummy_base{ void nonnull() {}; };
+
+        #undef DLIB_MSVC_INHERITANCE_VIRTUAL
+
+        typedef mp_impl_T<mp_null<dummy> > mp_null_impl;
+    public:
+
+        mfp_kernel_1_base_class (
+            const mfp_kernel_1_base_class& item
+        ) { item.mp()->clone(mp_memory.get()); }
+
+        mfp_kernel_1_base_class (  
+        ) { mp_null_impl().safe_clone(mp_memory); }
+
+        bool operator == (
+            const mfp_kernel_1_base_class& item
+        ) const { return mp()->is_same(item.mp()); }
+
+        bool operator != (
+            const mfp_kernel_1_base_class& item
+        ) const { return !(*this == item); }
+
+        mfp_kernel_1_base_class& operator= (
+            const mfp_kernel_1_base_class& item
+        ) { mfp_kernel_1_base_class(item).swap(*this); return *this;  }
+
+        ~mfp_kernel_1_base_class (
+        ) { destroy_mp_memory(); }
+
+        void clear(
+        ) { mfp_kernel_1_base_class().swap(*this); }
+
+        bool is_set (
+        ) const { return mp()->is_set(); } 
+
+    private:
+        typedef void (dummy::*safe_bool)();
+
+    public:
+        operator safe_bool () const { return is_set() ? &dummy::nonnull : 0; }
+        bool operator!() const { return !is_set(); }
+
+        void swap (
+            mfp_kernel_1_base_class& item
+        ) 
+        {  
+            // make a temp copy of item
+            mfp_kernel_1_base_class temp(item);
+
+            // destory the stuff in item
+            item.destroy_mp_memory();
+            // copy *this into item
+            mp()->clone(item.mp_memory.get());
+
+            // destory the stuff in this 
+            destroy_mp_memory();
+            // copy temp into *this
+            temp.mp()->clone(mp_memory.get());
+        }
+
+    protected:
+
+        // The reason for adding 1 here is because visual studio 2003 will sometimes
+        // try to compile this code with sizeof(mp_null_impl) == 0 (which is a bug in visual studio).
+        // Fortunately, no actual real instances of this template seem to end up with that screwed up
+        // value so everything works fine if we just add 1 so that this degenerate case doesn't cause
+        // trouble.  Note that we know it all works fine because safe_clone() checks the size of this
+        // memory block whenever the member function pointer is used.  
+        stack_based_memory_block<sizeof(mp_null_impl)+1> mp_memory;
+
+        void destroy_mp_memory (
+        )
+        {
+            // Honestly this probably doesn't even do anything but I'm putting
+            // it here just for good measure.
+            mp()->~mp_base_base();
+        }
+
+        mp_base_base*       mp ()       { return static_cast<mp_base_base*>(mp_memory.get()); }
+        const mp_base_base* mp () const { return static_cast<const mp_base_base*>(mp_memory.get()); }
+        
+    };
+
+// ----------------------------------------------------------------------------------------
+
+    template <>
+    class member_function_pointer<void,void,void,void> : public mfp_kernel_1_base_class<0>
+    {
+        class mp_base : public mp_base_base {
+        public:
+            mp_base(void* ptr, mfp_type type_) : mp_base_base(ptr,type_) {}
+            virtual void call() const = 0;
+        };
+
+        template <typename T>
+        class mp_impl : public mp_base {
+        public:
+            typedef void (T::*mfp_pointer_type)() ;
+            void call () const { (static_cast<T*>(this->o)->*callback)(); }
+
+            mp_impl      ( void* object, mfp_pointer_type cb) : mp_base(object, mfp_nonconst), callback(cb) {}
+            const mfp_pointer_type callback;
+        };
+
+        template <typename T>
+        class mp_impl_const : public mp_base {
+        public:
+            typedef void ((T::*mfp_pointer_type)()const);
+            void call () const  { (static_cast<const T*>(this->o)->*callback)(); }
+
+            mp_impl_const ( void* object, mfp_pointer_type cb) : mp_base(object,mfp_const), callback(cb) {}
+            const mfp_pointer_type callback;
+        };
+
+    public:
+        typedef void param1_type;
+        typedef void param2_type;
+        typedef void param3_type;
+        typedef void param4_type;
+
+        // These two typedefs are here for backwards compatibility with previous versions
+        // of dlib.
+        typedef member_function_pointer kernel_1a;
+        typedef member_function_pointer kernel_1a_c;
+
+
+        void operator() () const { DLIB_MFP_OC; static_cast<const mp_base*>(mp_memory.get())->call(); }
+
+        // the reason for putting disable_if on this function is that it avoids an overload
+        // resolution bug in visual studio.
+        template <typename T> typename disable_if<is_const_type<T>,void>::type 
+        set(T& object, typename mp_impl<T>::mfp_pointer_type cb) 
+        { DLIB_MFP_SC;  destroy_mp_memory(); mp_impl_T<mp_impl<T> >(&object,cb).safe_clone(mp_memory); }
+
+        template <typename T> void set(const T& object, typename mp_impl_const<T>::mfp_pointer_type cb) 
+        { DLIB_MFP_SC;  destroy_mp_memory(); mp_impl_T<mp_impl_const<T> >((void*)&object,cb).safe_clone(mp_memory); }
+
+    };    
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename PARAM1
+        >
+    class member_function_pointer<PARAM1,void,void,void> : public mfp_kernel_1_base_class<1>
+    {
+        class mp_base : public mp_base_base {
+        public:
+            mp_base(void* ptr, mfp_type type_) : mp_base_base(ptr,type_) {}
+            virtual void call(PARAM1) const = 0;
+        };
+
+        template <typename T>
+        class mp_impl : public mp_base {
+        public:
+            typedef void (T::*mfp_pointer_type)(PARAM1) ;
+            void call (PARAM1 p1) const { (static_cast<T*>(this->o)->*callback)(p1); }
+
+            mp_impl      ( void* object, mfp_pointer_type cb) : mp_base(object, mfp_nonconst), callback(cb) {}
+            const mfp_pointer_type callback;
+        };
+
+        template <typename T>
+        class mp_impl_const : public mp_base {
+        public:
+            typedef void ((T::*mfp_pointer_type)(PARAM1)const);
+            void call (PARAM1 p1) const  { (static_cast<const T*>(this->o)->*callback)(p1); }
+
+            mp_impl_const ( void* object, mfp_pointer_type cb) : mp_base(object,mfp_const), callback(cb) {}
+            const mfp_pointer_type callback;
+        };
+
+    public:
+        typedef PARAM1 param1_type;
+        typedef void param2_type;
+        typedef void param3_type;
+        typedef void param4_type;
+
+        // These two typedefs are here for backwards compatibility with previous versions
+        // of dlib.
+        typedef member_function_pointer kernel_1a;
+        typedef member_function_pointer kernel_1a_c;
+
+
+        void operator() (PARAM1 p1) const { DLIB_MFP_OC;  static_cast<const mp_base*>(mp_memory.get())->call(p1); }
+
+        // the reason for putting disable_if on this function is that it avoids an overload
+        // resolution bug in visual studio.
+        template <typename T> typename disable_if<is_const_type<T>,void>::type 
+        set(T& object, typename mp_impl<T>::mfp_pointer_type cb) 
+        { DLIB_MFP_SC;  destroy_mp_memory(); mp_impl_T<mp_impl<T> >(&object,cb).safe_clone(mp_memory); }
+
+        template <typename T> void set(const T& object, typename mp_impl_const<T>::mfp_pointer_type cb) 
+        { DLIB_MFP_SC;  destroy_mp_memory(); mp_impl_T<mp_impl_const<T> >((void*)&object,cb).safe_clone(mp_memory); }
+
+    };    
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename PARAM1,
+        typename PARAM2
+        >
+    class member_function_pointer<PARAM1,PARAM2,void,void> : public mfp_kernel_1_base_class<2>
+    {
+        class mp_base : public mp_base_base {
+        public:
+            mp_base(void* ptr, mfp_type type_) : mp_base_base(ptr,type_) {}
+            virtual void call(PARAM1,PARAM2) const = 0;
+        };
+
+        template <typename T>
+        class mp_impl : public mp_base {
+        public:
+            typedef void (T::*mfp_pointer_type)(PARAM1,PARAM2) ;
+            void call (PARAM1 p1, PARAM2 p2) const { (static_cast<T*>(this->o)->*callback)(p1,p2); }
+
+            mp_impl      ( void* object, mfp_pointer_type cb) : mp_base(object, mfp_nonconst), callback(cb) {}
+            const mfp_pointer_type callback;
+        };
+
+        template <typename T>
+        class mp_impl_const : public mp_base {
+        public:
+            typedef void ((T::*mfp_pointer_type)(PARAM1,PARAM2)const);
+            void call (PARAM1 p1, PARAM2 p2) const  { (static_cast<const T*>(this->o)->*callback)(p1,p2); }
+
+            mp_impl_const ( void* object, mfp_pointer_type cb) : mp_base(object,mfp_const), callback(cb) {}
+            const mfp_pointer_type callback;
+        };
+
+    public:
+        typedef PARAM1 param1_type;
+        typedef PARAM2 param2_type;
+        typedef void param3_type;
+        typedef void param4_type;
+
+        // These two typedefs are here for backwards compatibility with previous versions
+        // of dlib.
+        typedef member_function_pointer kernel_1a;
+        typedef member_function_pointer kernel_1a_c;
+
+        void operator() (PARAM1 p1, PARAM2 p2) const { DLIB_MFP_OC;  static_cast<const mp_base*>(mp_memory.get())->call(p1,p2); }
+
+        // the reason for putting disable_if on this function is that it avoids an overload
+        // resolution bug in visual studio.
+        template <typename T> typename disable_if<is_const_type<T>,void>::type 
+        set(T& object, typename mp_impl<T>::mfp_pointer_type cb) 
+        { DLIB_MFP_SC;  destroy_mp_memory(); mp_impl_T<mp_impl<T> >(&object,cb).safe_clone(mp_memory); }
+
+        template <typename T> void set(const T& object, typename mp_impl_const<T>::mfp_pointer_type cb) 
+        { DLIB_MFP_SC;  destroy_mp_memory(); mp_impl_T<mp_impl_const<T> >((void*)&object,cb).safe_clone(mp_memory); }
+
+    };    
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename PARAM1,
+        typename PARAM2,
+        typename PARAM3
+        >
+    class member_function_pointer<PARAM1,PARAM2,PARAM3,void> : public mfp_kernel_1_base_class<3>
+    {
+        class mp_base : public mp_base_base {
+        public:
+            mp_base(void* ptr, mfp_type type_) : mp_base_base(ptr,type_) {}
+            virtual void call(PARAM1,PARAM2,PARAM3) const = 0;
+        };
+
+        template <typename T>
+        class mp_impl : public mp_base {
+        public:
+            typedef void (T::*mfp_pointer_type)(PARAM1,PARAM2,PARAM3) ;
+            void call (PARAM1 p1, PARAM2 p2, PARAM3 p3) const { (static_cast<T*>(this->o)->*callback)(p1,p2,p3); }
+
+            mp_impl      ( void* object, mfp_pointer_type cb) : mp_base(object, mfp_nonconst), callback(cb) {}
+            const mfp_pointer_type callback;
+        };
+
+        template <typename T>
+        class mp_impl_const : public mp_base {
+        public:
+            typedef void ((T::*mfp_pointer_type)(PARAM1,PARAM2,PARAM3)const);
+            void call (PARAM1 p1, PARAM2 p2, PARAM3 p3) const  { (static_cast<const T*>(this->o)->*callback)(p1,p2,p3); }
+
+            mp_impl_const ( void* object, mfp_pointer_type cb) : mp_base(object,mfp_const), callback(cb) {}
+            const mfp_pointer_type callback;
+        };
+
+    public:
+        typedef PARAM1 param1_type;
+        typedef PARAM2 param2_type;
+        typedef PARAM3 param3_type;
+        typedef void param4_type;
+
+        // These two typedefs are here for backwards compatibility with previous versions
+        // of dlib.
+        typedef member_function_pointer kernel_1a;
+        typedef member_function_pointer kernel_1a_c;
+
+        void operator() (PARAM1 p1, PARAM2 p2, PARAM3 p3) const { DLIB_MFP_OC;  static_cast<const mp_base*>(mp_memory.get())->call(p1,p2,p3); }
+
+        // the reason for putting disable_if on this function is that it avoids an overload
+        // resolution bug in visual studio.
+        template <typename T> typename disable_if<is_const_type<T>,void>::type 
+        set(T& object, typename mp_impl<T>::mfp_pointer_type cb) 
+        { DLIB_MFP_SC;  destroy_mp_memory(); mp_impl_T<mp_impl<T> >(&object,cb).safe_clone(mp_memory); }
+
+        template <typename T> void set(const T& object, typename mp_impl_const<T>::mfp_pointer_type cb) 
+        { DLIB_MFP_SC;  destroy_mp_memory(); mp_impl_T<mp_impl_const<T> >((void*)&object,cb).safe_clone(mp_memory); }
+
+    };    
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename PARAM1,
+        typename PARAM2,
+        typename PARAM3,
+        typename PARAM4
+        >
+    class member_function_pointer : public mfp_kernel_1_base_class<4>
+    {
+        class mp_base : public mp_base_base {
+        public:
+            mp_base(void* ptr, mfp_type type_) : mp_base_base(ptr,type_) {}
+            virtual void call(PARAM1,PARAM2,PARAM3,PARAM4) const = 0;
+        };
+
+        template <typename T>
+        class mp_impl : public mp_base {
+        public:
+            typedef void (T::*mfp_pointer_type)(PARAM1,PARAM2,PARAM3, PARAM4) ;
+            void call (PARAM1 p1, PARAM2 p2, PARAM3 p3, PARAM4 p4) const { (static_cast<T*>(this->o)->*callback)(p1,p2,p3,p4); }
+
+            mp_impl      ( void* object, mfp_pointer_type cb) : mp_base(object, mfp_nonconst), callback(cb) {}
+            const mfp_pointer_type callback;
+        };
+
+        template <typename T>
+        class mp_impl_const : public mp_base {
+        public:
+            typedef void ((T::*mfp_pointer_type)(PARAM1,PARAM2,PARAM3,PARAM4)const);
+            void call (PARAM1 p1, PARAM2 p2, PARAM3 p3, PARAM4 p4) const  { (static_cast<const T*>(this->o)->*callback)(p1,p2,p3,p4); }
+
+            mp_impl_const ( void* object, mfp_pointer_type cb) : mp_base(object,mfp_const), callback(cb) {}
+            const mfp_pointer_type callback;
+        };
+
+    public:
+        typedef PARAM1 param1_type;
+        typedef PARAM2 param2_type;
+        typedef PARAM3 param3_type;
+        typedef PARAM4 param4_type;
+
+        // These two typedefs are here for backwards compatibility with previous versions
+        // of dlib.
+        typedef member_function_pointer kernel_1a;
+        typedef member_function_pointer kernel_1a_c;
+
+        void operator() (PARAM1 p1, PARAM2 p2, PARAM3 p3, PARAM4 p4) const 
+        { DLIB_MFP_OC;  static_cast<const mp_base*>(mp_memory.get())->call(p1,p2,p3,p4); }
+
+        // the reason for putting disable_if on this function is that it avoids an overload
+        // resolution bug in visual studio.
+        template <typename T> typename disable_if<is_const_type<T>,void>::type 
+        set(T& object, typename mp_impl<T>::mfp_pointer_type cb) 
+        { DLIB_MFP_SC;  destroy_mp_memory(); mp_impl_T<mp_impl<T> >(&object,cb).safe_clone(mp_memory); }
+
+        template <typename T> void set(const T& object, typename mp_impl_const<T>::mfp_pointer_type cb) 
+        { DLIB_MFP_SC;  destroy_mp_memory(); mp_impl_T<mp_impl_const<T> >((void*)&object,cb).safe_clone(mp_memory); }
+
+    };    
+
+// ----------------------------------------------------------------------------------------
+
+}
+
+#endif // DLIB_MEMBER_FUNCTION_POINTER_KERNEl_1_
+

Plugins/GameLiftServerSDK/ThirdParty/concurrentqueue/benchmarks/dlib/member_function_pointer/member_function_pointer_kernel_abstract.h

@@ -0,0 +1,483 @@
+// Copyright (C) 2005  Davis E. King (davis@dlib.net)
+// License: Boost Software License   See LICENSE.txt for the full license.
+#undef DLIB_MEMBER_FUNCTION_POINTER_KERNEl_ABSTRACT_
+#ifdef DLIB_MEMBER_FUNCTION_POINTER_KERNEl_ABSTRACT_
+
+namespace dlib
+{
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename PARAM1 = void,
+        typename PARAM2 = void,
+        typename PARAM3 = void,
+        typename PARAM4 = void
+        >
+    class member_function_pointer;
+
+// ----------------------------------------------------------------------------------------
+
+    template <>
+    class member_function_pointer<void,void,void,void>
+    {
+        /*!
+            INITIAL VALUE
+                is_set() == false
+
+            WHAT THIS OBJECT REPRESENTS
+                This object represents a member function pointer.  It is useful because
+                instances of this object can be created without needing to know the type
+                of object whose member function we will be calling.
+
+                There are five template specializations of this object.  The first 
+                represents a pointer to a member function taking no parameters, the
+                second represents a pointer to a member function taking one parameter, 
+                the third to one taking two parameters, and so on.
+
+                You specify the parameters to your member function pointer by filling in
+                the PARAM template parameters.  For example:
+
+                    To use a pointer to a function with no parameters you would say:
+                        member_function_pointer<> my_pointer;
+                    To use a pointer to a function that takes a single int you would say:
+                        member_function_pointer<int> my_pointer;
+                    To use a pointer to a function that takes an int and then a reference
+                    to a string you would say:
+                        member_function_pointer<int,string&> my_pointer;
+
+                Also note that the formal comments are only present for the first 
+                template specialization.  They are all exactly the same except for the 
+                number of parameters each takes in its member function pointer.
+        !*/
+
+    public:
+        typedef void param1_type;
+        typedef void param2_type;
+        typedef void param3_type;
+        typedef void param4_type;
+
+        member_function_pointer (  
+        );
+        /*!
+            ensures                
+                - #*this is properly initialized
+        !*/
+
+        member_function_pointer(
+            const member_function_pointer& item
+        );
+        /*!
+            ensures
+                - *this == item
+        !*/
+
+        ~member_function_pointer (
+        );
+        /*!
+            ensures
+                - any resources associated with *this have been released
+        !*/
+
+        member_function_pointer& operator=(
+            const member_function_pointer& item
+        );
+        /*!
+            ensures
+                - *this == item
+        !*/
+
+        bool operator == (
+            const member_function_pointer& item
+        ) const;
+        /*!
+            ensures
+                - if (is_set() == false && item.is_set() == false) then
+                    - returns true
+                - else if (both *this and item point to the same member function
+                  in the same object instance) then
+                    - returns true
+                - else
+                    - returns false
+        !*/
+
+        bool operator != (
+            const member_function_pointer& item
+        ) const;
+        /*!
+            ensures
+                - returns !(*this == item)
+        !*/
+
+        void clear(
+        );
+        /*!
+            ensures
+                - #*this has its initial value
+        !*/
+
+        bool is_set (
+        ) const;
+        /*!
+            ensures
+                - if (this->set() has been called) then
+                    - returns true
+                - else
+                    - returns false
+        !*/
+
+        template <
+            typename T
+            >
+        void set (
+            T& object,
+            void (T::*cb)()
+        );
+        /*!
+            requires
+                - cb == a valid member function pointer for class T
+            ensures
+                - #is_set() == true
+                - calls to this->operator() will call (object.*cb)()
+        !*/
+
+        template <
+            typename T
+            >
+        void set (
+            const T& object,
+            void (T::*cb)()const
+        );
+        /*!
+            requires
+                - cb == a valid member function pointer for class T
+            ensures
+                - #is_set() == true
+                - calls to this->operator() will call (object.*cb)()
+        !*/
+
+        operator some_undefined_pointer_type (
+        ) const;
+        /*!
+            ensures
+                - if (is_set()) then
+                    - returns a non 0 value
+                - else
+                    - returns a 0 value
+        !*/
+
+        bool operator! (
+        ) const;
+        /*!
+            ensures
+                - returns !is_set()
+        !*/
+
+        void operator () (
+        ) const;
+        /*!
+            requires
+                - is_set() == true
+            ensures
+                - calls the member function on the object specified by the last 
+                  call to this->set()
+            throws
+                - any exception thrown by the member function specified by
+                  the previous call to this->set().
+                    If any of these exceptions are thrown then the call to this 
+                    function will have no effect on *this.                  
+        !*/
+
+        void swap (
+            member_function_pointer& item
+        );
+        /*!
+            ensures
+                - swaps *this and item
+        !*/ 
+
+    };    
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename PARAM1
+        >
+    class member_function_pointer<PARAM1,void,void,void>
+    {
+    public:
+        typedef PARAM1 param1_type;
+        typedef void param2_type;
+        typedef void param3_type;
+        typedef void param4_type;
+
+        member_function_pointer ();
+
+        member_function_pointer(
+            const member_function_pointer& item
+        );
+
+        ~member_function_pointer (
+        );
+
+        member_function_pointer& operator=(
+            const member_function_pointer& item
+        );
+
+        bool operator == (
+            const member_function_pointer& item
+        ) const;
+
+        bool operator != (
+            const member_function_pointer& item
+        ) const;
+
+        void clear();
+
+        bool is_set () const;
+
+        template <typename T>
+        void set (
+            T& object,
+            void (T::*cb)(PARAM1)
+        );
+
+        template <typename T>
+        void set (
+            const T& object,
+            void (T::*cb)(PARAM1)const
+        );
+
+        operator some_undefined_pointer_type (
+        ) const;
+
+        bool operator! (
+        ) const;
+
+        void operator () (
+            PARAM1 param1
+        ) const;
+
+        void swap (
+            member_function_pointer& item
+        );
+
+    };    
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename PARAM1,
+        typename PARAM2
+        >
+    class member_function_pointer<PARAM1,PARAM2,void,void>
+    {
+    public:
+        typedef PARAM1 param1_type;
+        typedef PARAM2 param2_type;
+        typedef void param3_type;
+        typedef void param4_type;
+
+        member_function_pointer ();
+
+        member_function_pointer(
+            const member_function_pointer& item
+        );
+
+        ~member_function_pointer (
+        );
+
+        member_function_pointer& operator=(
+            const member_function_pointer& item
+        );
+
+        bool operator == (
+            const member_function_pointer& item
+        ) const;
+
+        bool operator != (
+            const member_function_pointer& item
+        ) const;
+
+        void clear();
+
+        bool is_set () const;
+
+        template <typename T>
+        void set (
+            T& object,
+            void (T::*cb)(PARAM1,PARAM2)
+        );
+
+        template <typename T>
+        void set (
+            const T& object,
+            void (T::*cb)(PARAM1,PARAM2)const
+        );
+
+        operator some_undefined_pointer_type (
+        ) const;
+
+        bool operator! (
+        ) const;
+
+        void operator () (
+            PARAM1 param1,
+            PARAM2 param2
+        ) const;
+
+        void swap (
+            member_function_pointer& item
+        );
+
+    };    
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename PARAM1,
+        typename PARAM2,
+        typename PARAM3
+        >
+    class member_function_pointer<PARAM1,PARAM2,PARAM3,void>
+    {
+    public:
+        typedef PARAM1 param1_type;
+        typedef PARAM2 param2_type;
+        typedef PARAM3 param3_type;
+        typedef void param4_type;
+
+        member_function_pointer ();
+
+        member_function_pointer(
+            const member_function_pointer& item
+        );
+
+        ~member_function_pointer (
+        );
+
+        member_function_pointer& operator=(
+            const member_function_pointer& item
+        );
+
+        bool operator == (
+            const member_function_pointer& item
+        ) const;
+
+        bool operator != (
+            const member_function_pointer& item
+        ) const;
+
+        void clear();
+
+        bool is_set () const;
+
+        template <typename T>
+        void set (
+            T& object,
+            void (T::*cb)(PARAM1,PARAM2,PARAM3)
+        );
+
+        template <typename T>
+        void set (
+            const T& object,
+            void (T::*cb)(PARAM1,PARAM2,PARAM3)const
+        );
+
+        operator some_undefined_pointer_type (
+        ) const;
+
+        bool operator! (
+        ) const;
+
+        void operator () (
+            PARAM1 param1,
+            PARAM2 param2,
+            PARAM2 param3
+        ) const;
+
+        void swap (
+            member_function_pointer& item
+        );
+
+    };    
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename PARAM1,
+        typename PARAM2,
+        typename PARAM3,
+        typename PARAM4
+        >
+    class member_function_pointer
+    {
+    public:
+        typedef PARAM1 param1_type;
+        typedef PARAM2 param2_type;
+        typedef PARAM3 param3_type;
+        typedef PARAM4 param4_type;
+
+        member_function_pointer ();
+
+        member_function_pointer(
+            const member_function_pointer& item
+        );
+
+        ~member_function_pointer (
+        );
+
+        member_function_pointer& operator=(
+            const member_function_pointer& item
+        );
+
+        bool operator == (
+            const member_function_pointer& item
+        ) const;
+
+        bool operator != (
+            const member_function_pointer& item
+        ) const;
+
+        void clear();
+
+        bool is_set () const;
+
+        template <typename T>
+        void set (
+            T& object,
+            void (T::*cb)(PARAM1,PARAM2,PARAM3,PARAM4)
+        );
+
+        template <typename T>
+        void set (
+            const T& object,
+            void (T::*cb)(PARAM1,PARAM2,PARAM3,PARAM4)const
+        );
+
+        operator some_undefined_pointer_type (
+        ) const;
+
+        bool operator! (
+        ) const;
+
+        void operator () (
+            PARAM1 param1,
+            PARAM2 param2,
+            PARAM2 param3,
+            PARAM2 param4
+        ) const;
+
+        void swap (
+            member_function_pointer& item
+        );
+
+    };    
+
+// ----------------------------------------------------------------------------------------
+
+
+}
+
+#endif // DLIB_MEMBER_FUNCTION_POINTER_KERNEl_ABSTRACT_
+