summaryrefslogtreecommitdiffstats
path: root/ml/dlib/dlib/member_function_pointer/member_function_pointer_kernel_1.h
diff options
context:
space:
mode:
Diffstat (limited to 'ml/dlib/dlib/member_function_pointer/member_function_pointer_kernel_1.h')
-rw-r--r--ml/dlib/dlib/member_function_pointer/member_function_pointer_kernel_1.h498
1 files changed, 0 insertions, 498 deletions
diff --git a/ml/dlib/dlib/member_function_pointer/member_function_pointer_kernel_1.h b/ml/dlib/dlib/member_function_pointer/member_function_pointer_kernel_1.h
deleted file mode 100644
index 6cf5630b4..000000000
--- a/ml/dlib/dlib/member_function_pointer/member_function_pointer_kernel_1.h
+++ /dev/null
@@ -1,498 +0,0 @@
-// 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;
- }
- };
-
- struct dummy_base { virtual void nonnull() {}; virtual ~dummy_base(){}; int a; };
- struct dummy : virtual public dummy_base{ void nonnull() {}; };
-
- 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_
-
generated by cgit v1.2.3 (git 2.39.1) at 2024-05-19 04:58:48 +0000