11027 lines
511 KiB
C++
11027 lines
511 KiB
C++
|
|
///////////////////////////////////////////
|
|
// helper templates for use with stl <functional>
|
|
// providing argument binding for more arities
|
|
// and proper const support
|
|
///////////////////////////////////////////
|
|
|
|
#pragma once
|
|
#pragma warning(disable:4181)
|
|
|
|
#include <functional>
|
|
|
|
///////////////////////////////////////////
|
|
// Types
|
|
///////////////////////////////////////////
|
|
|
|
// Type classes for arity 0
|
|
|
|
template<class R> class arity0_function {
|
|
public:
|
|
typedef R result_type;
|
|
};
|
|
|
|
// Template Class to define Object Type
|
|
template<class Object> class ObjectType {
|
|
public:
|
|
typedef Object object_type;
|
|
};
|
|
|
|
// template class for arity0 member function type
|
|
template<class Object, class R> class arity0_mf :
|
|
public ObjectType<Object> ,
|
|
public arity0_function<R> {
|
|
public:
|
|
typedef R (Object::*pmf0type)();
|
|
};
|
|
|
|
// template class for arity0 member function type
|
|
template<class Object, class R> class arity0_const_mf :
|
|
public ObjectType<Object> ,
|
|
public arity0_function<R> {
|
|
public:
|
|
typedef R (Object::*pmf0type)() const;
|
|
};
|
|
|
|
|
|
// Type classes for arity 1
|
|
|
|
// template class for arity1 member function type
|
|
template<class Object,
|
|
class A1,
|
|
class R> class arity1_mf :
|
|
public ObjectType<Object> ,
|
|
public std::unary_function<A1,
|
|
R> {
|
|
public:
|
|
typedef R (Object::*pmf1type)(A1);
|
|
};
|
|
|
|
// template class for arity1 member function type
|
|
template<class Object,
|
|
class A1,
|
|
class R> class arity1_const_mf :
|
|
public ObjectType<Object> ,
|
|
public std::unary_function<A1,
|
|
R> {
|
|
public:
|
|
typedef R (Object::*pmf1type)(A1) const;
|
|
};
|
|
|
|
|
|
// Type classes for arity 2
|
|
|
|
// template class for arity2 member function type
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class R> class arity2_mf :
|
|
public ObjectType<Object> ,
|
|
public std::binary_function<A1,
|
|
A2,
|
|
R> {
|
|
public:
|
|
typedef first_argument_type argument_type;
|
|
typedef R (Object::*pmf2type)(A1, A2);
|
|
};
|
|
|
|
// template class for arity2 member function type
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class R> class arity2_const_mf :
|
|
public ObjectType<Object> ,
|
|
public std::binary_function<A1,
|
|
A2,
|
|
R> {
|
|
public:
|
|
typedef first_argument_type argument_type;
|
|
typedef R (Object::*pmf2type)(A1, A2) const;
|
|
};
|
|
|
|
|
|
// Type classes for arity 3
|
|
|
|
template<class A1,
|
|
class A2,
|
|
class A3,
|
|
class R> class arity3_function :
|
|
public std::binary_function<A1,
|
|
A2,
|
|
R> {
|
|
public:typedef first_argument_type argument_type;
|
|
|
|
typedef A3 argument_3_type;
|
|
};
|
|
|
|
// template class for arity3 member function type
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class R> class arity3_mf :
|
|
public ObjectType<Object> ,
|
|
public arity3_function<A1,
|
|
A2,
|
|
A3,
|
|
R> {
|
|
public:
|
|
typedef R (Object::*pmf3type)(A1, A2, A3);
|
|
};
|
|
|
|
// template class for arity3 member function type
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class R> class arity3_const_mf :
|
|
public ObjectType<Object> ,
|
|
public arity3_function<A1,
|
|
A2,
|
|
A3,
|
|
R> {
|
|
public:
|
|
typedef R (Object::*pmf3type)(A1, A2, A3) const;
|
|
};
|
|
|
|
|
|
// Type classes for arity 4
|
|
|
|
template<class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class R> class arity4_function :
|
|
public arity3_function<A1,
|
|
A2,
|
|
A3,
|
|
R> {
|
|
public:
|
|
typedef A4 argument_4_type;
|
|
};
|
|
|
|
// template class for arity4 member function type
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class R> class arity4_mf :
|
|
public ObjectType<Object> ,
|
|
public arity4_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
R> {
|
|
public:
|
|
typedef R (Object::*pmf4type)(A1, A2, A3, A4);
|
|
};
|
|
|
|
// template class for arity4 member function type
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class R> class arity4_const_mf :
|
|
public ObjectType<Object> ,
|
|
public arity4_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
R> {
|
|
public:
|
|
typedef R (Object::*pmf4type)(A1, A2, A3, A4) const;
|
|
};
|
|
|
|
|
|
// Type classes for arity 5
|
|
|
|
template<class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class R> class arity5_function :
|
|
public arity4_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
R> {
|
|
public:
|
|
typedef A5 argument_5_type;
|
|
};
|
|
|
|
// template class for arity5 member function type
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class R> class arity5_mf :
|
|
public ObjectType<Object> ,
|
|
public arity5_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
R> {
|
|
public:
|
|
typedef R (Object::*pmf5type)(A1, A2, A3, A4, A5);
|
|
};
|
|
|
|
// template class for arity5 member function type
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class R> class arity5_const_mf :
|
|
public ObjectType<Object> ,
|
|
public arity5_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
R> {
|
|
public:
|
|
typedef R (Object::*pmf5type)(A1, A2, A3, A4, A5) const;
|
|
};
|
|
|
|
|
|
// Type classes for arity 6
|
|
|
|
template<class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6,
|
|
class R> class arity6_function :
|
|
public arity5_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
R> {
|
|
public:
|
|
typedef A6 argument_6_type;
|
|
};
|
|
|
|
// template class for arity6 member function type
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6,
|
|
class R> class arity6_mf :
|
|
public ObjectType<Object> ,
|
|
public arity6_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
R> {
|
|
public:
|
|
typedef R (Object::*pmf6type)(A1, A2, A3, A4, A5, A6);
|
|
};
|
|
|
|
// template class for arity6 member function type
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6,
|
|
class R> class arity6_const_mf :
|
|
public ObjectType<Object> ,
|
|
public arity6_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
R> {
|
|
public:
|
|
typedef R (Object::*pmf6type)(A1, A2, A3, A4, A5, A6) const;
|
|
};
|
|
|
|
|
|
// Type classes for arity 7
|
|
|
|
template<class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6,
|
|
class A7,
|
|
class R> class arity7_function :
|
|
public arity6_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
R> {
|
|
public:
|
|
typedef A7 argument_7_type;
|
|
};
|
|
|
|
// template class for arity7 member function type
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6,
|
|
class A7,
|
|
class R> class arity7_mf :
|
|
public ObjectType<Object> ,
|
|
public arity7_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
A7,
|
|
R> {
|
|
public:
|
|
typedef R (Object::*pmf7type)(A1, A2, A3, A4, A5, A6, A7);
|
|
};
|
|
|
|
// template class for arity7 member function type
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6,
|
|
class A7,
|
|
class R> class arity7_const_mf :
|
|
public ObjectType<Object> ,
|
|
public arity7_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
A7,
|
|
R> {
|
|
public:
|
|
typedef R (Object::*pmf7type)(A1, A2, A3, A4, A5, A6, A7) const;
|
|
};
|
|
|
|
|
|
// Type classes for arity 8
|
|
|
|
template<class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6,
|
|
class A7,
|
|
class A8,
|
|
class R> class arity8_function :
|
|
public arity7_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
A7,
|
|
R> {
|
|
public:
|
|
typedef A8 argument_8_type;
|
|
};
|
|
|
|
// template class for arity8 member function type
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6,
|
|
class A7,
|
|
class A8,
|
|
class R> class arity8_mf :
|
|
public ObjectType<Object> ,
|
|
public arity8_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
A7,
|
|
A8,
|
|
R> {
|
|
public:
|
|
typedef R (Object::*pmf8type)(A1, A2, A3, A4, A5, A6, A7, A8);
|
|
};
|
|
|
|
// template class for arity8 member function type
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6,
|
|
class A7,
|
|
class A8,
|
|
class R> class arity8_const_mf :
|
|
public ObjectType<Object> ,
|
|
public arity8_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
A7,
|
|
A8,
|
|
R> {
|
|
public:
|
|
typedef R (Object::*pmf8type)(A1, A2, A3, A4, A5, A6, A7, A8) const;
|
|
};
|
|
|
|
|
|
// Type classes for arity 9
|
|
|
|
template<class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6,
|
|
class A7,
|
|
class A8,
|
|
class A9,
|
|
class R> class arity9_function :
|
|
public arity8_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
A7,
|
|
A8,
|
|
R> {
|
|
public:
|
|
typedef A9 argument_9_type;
|
|
};
|
|
|
|
// template class for arity9 member function type
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6,
|
|
class A7,
|
|
class A8,
|
|
class A9,
|
|
class R> class arity9_mf :
|
|
public ObjectType<Object> ,
|
|
public arity9_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
A7,
|
|
A8,
|
|
A9,
|
|
R> {
|
|
public:
|
|
typedef R (Object::*pmf9type)(A1, A2, A3, A4, A5, A6, A7, A8, A9);
|
|
};
|
|
|
|
// template class for arity9 member function type
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6,
|
|
class A7,
|
|
class A8,
|
|
class A9,
|
|
class R> class arity9_const_mf :
|
|
public ObjectType<Object> ,
|
|
public arity9_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
A7,
|
|
A8,
|
|
A9,
|
|
R> {
|
|
public:
|
|
typedef R (Object::*pmf9type)(A1, A2, A3, A4, A5, A6, A7, A8, A9) const;
|
|
};
|
|
|
|
|
|
// Type classes for arity 10
|
|
|
|
template<class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6,
|
|
class A7,
|
|
class A8,
|
|
class A9,
|
|
class A10,
|
|
class R> class arity10_function :
|
|
public arity9_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
A7,
|
|
A8,
|
|
A9,
|
|
R> {
|
|
public:
|
|
typedef A10 argument_10_type;
|
|
};
|
|
|
|
// template class for arity10 member function type
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6,
|
|
class A7,
|
|
class A8,
|
|
class A9,
|
|
class A10,
|
|
class R> class arity10_mf :
|
|
public ObjectType<Object> ,
|
|
public arity10_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
A7,
|
|
A8,
|
|
A9,
|
|
A10,
|
|
R> {
|
|
public:
|
|
typedef R (Object::*pmf10type)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);
|
|
};
|
|
|
|
// template class for arity10 member function type
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6,
|
|
class A7,
|
|
class A8,
|
|
class A9,
|
|
class A10,
|
|
class R> class arity10_const_mf :
|
|
public ObjectType<Object> ,
|
|
public arity10_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
A7,
|
|
A8,
|
|
A9,
|
|
A10,
|
|
R> {
|
|
public:
|
|
typedef R (Object::*pmf10type)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) const;
|
|
};
|
|
|
|
|
|
// Type classes for arity 11
|
|
|
|
template<class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6,
|
|
class A7,
|
|
class A8,
|
|
class A9,
|
|
class A10,
|
|
class A11,
|
|
class R> class arity11_function :
|
|
public arity10_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
A7,
|
|
A8,
|
|
A9,
|
|
A10,
|
|
R> {
|
|
public:
|
|
typedef A11 argument_11_type;
|
|
};
|
|
|
|
// template class for arity11 member function type
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6,
|
|
class A7,
|
|
class A8,
|
|
class A9,
|
|
class A10,
|
|
class A11,
|
|
class R> class arity11_mf :
|
|
public ObjectType<Object> ,
|
|
public arity11_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
A7,
|
|
A8,
|
|
A9,
|
|
A10,
|
|
A11,
|
|
R> {
|
|
public:
|
|
typedef R (Object::*pmf11type)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11);
|
|
};
|
|
|
|
// template class for arity11 member function type
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6,
|
|
class A7,
|
|
class A8,
|
|
class A9,
|
|
class A10,
|
|
class A11,
|
|
class R> class arity11_const_mf :
|
|
public ObjectType<Object> ,
|
|
public arity11_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
A7,
|
|
A8,
|
|
A9,
|
|
A10,
|
|
A11,
|
|
R> {
|
|
public:
|
|
typedef R (Object::*pmf11type)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) const;
|
|
};
|
|
|
|
|
|
// Type classes for arity 12
|
|
|
|
template<class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6,
|
|
class A7,
|
|
class A8,
|
|
class A9,
|
|
class A10,
|
|
class A11,
|
|
class A12,
|
|
class R> class arity12_function :
|
|
public arity11_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
A7,
|
|
A8,
|
|
A9,
|
|
A10,
|
|
A11,
|
|
R> {
|
|
public:
|
|
typedef A12 argument_12_type;
|
|
};
|
|
|
|
// template class for arity12 member function type
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6,
|
|
class A7,
|
|
class A8,
|
|
class A9,
|
|
class A10,
|
|
class A11,
|
|
class A12,
|
|
class R> class arity12_mf :
|
|
public ObjectType<Object> ,
|
|
public arity12_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
A7,
|
|
A8,
|
|
A9,
|
|
A10,
|
|
A11,
|
|
A12,
|
|
R> {
|
|
public:
|
|
typedef R (Object::*pmf12type)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12);
|
|
};
|
|
|
|
// template class for arity12 member function type
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6,
|
|
class A7,
|
|
class A8,
|
|
class A9,
|
|
class A10,
|
|
class A11,
|
|
class A12,
|
|
class R> class arity12_const_mf :
|
|
public ObjectType<Object> ,
|
|
public arity12_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
A7,
|
|
A8,
|
|
A9,
|
|
A10,
|
|
A11,
|
|
A12,
|
|
R> {
|
|
public:
|
|
typedef R (Object::*pmf12type)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) const;
|
|
};
|
|
|
|
|
|
// Type classes for arity 13
|
|
|
|
template<class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6,
|
|
class A7,
|
|
class A8,
|
|
class A9,
|
|
class A10,
|
|
class A11,
|
|
class A12,
|
|
class A13,
|
|
class R> class arity13_function :
|
|
public arity12_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
A7,
|
|
A8,
|
|
A9,
|
|
A10,
|
|
A11,
|
|
A12,
|
|
R> {
|
|
public:
|
|
typedef A13 argument_13_type;
|
|
};
|
|
|
|
// template class for arity13 member function type
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6,
|
|
class A7,
|
|
class A8,
|
|
class A9,
|
|
class A10,
|
|
class A11,
|
|
class A12,
|
|
class A13,
|
|
class R> class arity13_mf :
|
|
public ObjectType<Object> ,
|
|
public arity13_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
A7,
|
|
A8,
|
|
A9,
|
|
A10,
|
|
A11,
|
|
A12,
|
|
A13,
|
|
R> {
|
|
public:
|
|
typedef R (Object::*pmf13type)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13);
|
|
};
|
|
|
|
// template class for arity13 member function type
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6,
|
|
class A7,
|
|
class A8,
|
|
class A9,
|
|
class A10,
|
|
class A11,
|
|
class A12,
|
|
class A13,
|
|
class R> class arity13_const_mf :
|
|
public ObjectType<Object> ,
|
|
public arity13_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
A7,
|
|
A8,
|
|
A9,
|
|
A10,
|
|
A11,
|
|
A12,
|
|
A13,
|
|
R> {
|
|
public:
|
|
typedef R (Object::*pmf13type)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) const;
|
|
};
|
|
|
|
|
|
// Type classes for arity 14
|
|
|
|
template<class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6,
|
|
class A7,
|
|
class A8,
|
|
class A9,
|
|
class A10,
|
|
class A11,
|
|
class A12,
|
|
class A13,
|
|
class A14,
|
|
class R> class arity14_function :
|
|
public arity13_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
A7,
|
|
A8,
|
|
A9,
|
|
A10,
|
|
A11,
|
|
A12,
|
|
A13,
|
|
R> {
|
|
public:
|
|
typedef A14 argument_14_type;
|
|
};
|
|
|
|
// template class for arity14 member function type
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6,
|
|
class A7,
|
|
class A8,
|
|
class A9,
|
|
class A10,
|
|
class A11,
|
|
class A12,
|
|
class A13,
|
|
class A14,
|
|
class R> class arity14_mf :
|
|
public ObjectType<Object> ,
|
|
public arity14_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
A7,
|
|
A8,
|
|
A9,
|
|
A10,
|
|
A11,
|
|
A12,
|
|
A13,
|
|
A14,
|
|
R> {
|
|
public:
|
|
typedef R (Object::*pmf14type)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14);
|
|
};
|
|
|
|
// template class for arity14 member function type
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6,
|
|
class A7,
|
|
class A8,
|
|
class A9,
|
|
class A10,
|
|
class A11,
|
|
class A12,
|
|
class A13,
|
|
class A14,
|
|
class R> class arity14_const_mf :
|
|
public ObjectType<Object> ,
|
|
public arity14_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
A7,
|
|
A8,
|
|
A9,
|
|
A10,
|
|
A11,
|
|
A12,
|
|
A13,
|
|
A14,
|
|
R> {
|
|
public:
|
|
typedef R (Object::*pmf14type)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) const;
|
|
};
|
|
|
|
|
|
// Type classes for arity 15
|
|
|
|
template<class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6,
|
|
class A7,
|
|
class A8,
|
|
class A9,
|
|
class A10,
|
|
class A11,
|
|
class A12,
|
|
class A13,
|
|
class A14,
|
|
class A15,
|
|
class R> class arity15_function :
|
|
public arity14_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
A7,
|
|
A8,
|
|
A9,
|
|
A10,
|
|
A11,
|
|
A12,
|
|
A13,
|
|
A14,
|
|
R> {
|
|
public:
|
|
typedef A15 argument_15_type;
|
|
};
|
|
|
|
// template class for arity15 member function type
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6,
|
|
class A7,
|
|
class A8,
|
|
class A9,
|
|
class A10,
|
|
class A11,
|
|
class A12,
|
|
class A13,
|
|
class A14,
|
|
class A15,
|
|
class R> class arity15_mf :
|
|
public ObjectType<Object> ,
|
|
public arity15_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
A7,
|
|
A8,
|
|
A9,
|
|
A10,
|
|
A11,
|
|
A12,
|
|
A13,
|
|
A14,
|
|
A15,
|
|
R> {
|
|
public:
|
|
typedef R (Object::*pmf15type)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15);
|
|
};
|
|
|
|
// template class for arity15 member function type
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6,
|
|
class A7,
|
|
class A8,
|
|
class A9,
|
|
class A10,
|
|
class A11,
|
|
class A12,
|
|
class A13,
|
|
class A14,
|
|
class A15,
|
|
class R> class arity15_const_mf :
|
|
public ObjectType<Object> ,
|
|
public arity15_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
A7,
|
|
A8,
|
|
A9,
|
|
A10,
|
|
A11,
|
|
A12,
|
|
A13,
|
|
A14,
|
|
A15,
|
|
R> {
|
|
public:
|
|
typedef R (Object::*pmf15type)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) const;
|
|
};
|
|
|
|
// template class for arity0 member function type
|
|
template<class Object, class R> class std_arity0_mf :
|
|
public ObjectType<Object> ,
|
|
public arity0_function<R> {
|
|
public:
|
|
typedef R ( __stdcall Object::*pmf0type)();
|
|
};
|
|
|
|
// template class for arity0 member function type
|
|
template<class Object, class R> class std_arity0_const_mf :
|
|
public ObjectType<Object> ,
|
|
public arity0_function<R> {
|
|
public:
|
|
typedef R ( __stdcall Object::*pmf0type)() const;
|
|
};
|
|
|
|
// template class for arity1 member function type
|
|
template<class Object,
|
|
class A1,
|
|
class R> class std_arity1_mf :
|
|
public ObjectType<Object> ,
|
|
public std::unary_function<A1,
|
|
R> {
|
|
public:
|
|
typedef R ( __stdcall Object::*pmf1type)(A1);
|
|
};
|
|
|
|
// template class for arity1 member function type
|
|
template<class Object,
|
|
class A1,
|
|
class R> class std_arity1_const_mf :
|
|
public ObjectType<Object> ,
|
|
public std::unary_function<A1,
|
|
R> {
|
|
public:
|
|
typedef R ( __stdcall Object::*pmf1type)(A1) const;
|
|
};
|
|
|
|
// template class for arity2 member function type
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class R> class std_arity2_mf :
|
|
public ObjectType<Object> ,
|
|
public std::binary_function<A1,
|
|
A2,
|
|
R> {
|
|
public:
|
|
typedef first_argument_type argument_type;
|
|
typedef R ( __stdcall Object::*pmf2type)(A1, A2);
|
|
};
|
|
|
|
// template class for arity2 member function type
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class R> class std_arity2_const_mf :
|
|
public ObjectType<Object> ,
|
|
public std::binary_function<A1,
|
|
A2,
|
|
R> {
|
|
public:
|
|
typedef first_argument_type argument_type;
|
|
typedef R ( __stdcall Object::*pmf2type)(A1, A2) const;
|
|
};
|
|
|
|
// template class for arity3 member function type
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class R> class std_arity3_mf :
|
|
public ObjectType<Object> ,
|
|
public arity3_function<A1,
|
|
A2,
|
|
A3,
|
|
R> {
|
|
public:
|
|
typedef R ( __stdcall Object::*pmf3type)(A1, A2, A3);
|
|
};
|
|
|
|
// template class for arity3 member function type
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class R> class std_arity3_const_mf :
|
|
public ObjectType<Object> ,
|
|
public arity3_function<A1,
|
|
A2,
|
|
A3,
|
|
R> {
|
|
public:
|
|
typedef R ( __stdcall Object::*pmf3type)(A1, A2, A3) const;
|
|
};
|
|
|
|
// template class for arity4 member function type
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class R> class std_arity4_mf :
|
|
public ObjectType<Object> ,
|
|
public arity4_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
R> {
|
|
public:
|
|
typedef R ( __stdcall Object::*pmf4type)(A1, A2, A3, A4);
|
|
};
|
|
|
|
// template class for arity4 member function type
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class R> class std_arity4_const_mf :
|
|
public ObjectType<Object> ,
|
|
public arity4_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
R> {
|
|
public:
|
|
typedef R ( __stdcall Object::*pmf4type)(A1, A2, A3, A4) const;
|
|
};
|
|
|
|
// template class for arity5 member function type
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class R> class std_arity5_mf :
|
|
public ObjectType<Object> ,
|
|
public arity5_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
R> {
|
|
public:
|
|
typedef R ( __stdcall Object::*pmf5type)(A1, A2, A3, A4, A5);
|
|
};
|
|
|
|
// template class for arity5 member function type
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class R> class std_arity5_const_mf :
|
|
public ObjectType<Object> ,
|
|
public arity5_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
R> {
|
|
public:
|
|
typedef R ( __stdcall Object::*pmf5type)(A1, A2, A3, A4, A5) const;
|
|
};
|
|
|
|
// template class for arity6 member function type
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6,
|
|
class R> class std_arity6_mf :
|
|
public ObjectType<Object> ,
|
|
public arity6_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
R> {
|
|
public:
|
|
typedef R ( __stdcall Object::*pmf6type)(A1, A2, A3, A4, A5, A6);
|
|
};
|
|
|
|
// template class for arity6 member function type
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6,
|
|
class R> class std_arity6_const_mf :
|
|
public ObjectType<Object> ,
|
|
public arity6_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
R> {
|
|
public:
|
|
typedef R ( __stdcall Object::*pmf6type)(A1, A2, A3, A4, A5, A6) const;
|
|
};
|
|
|
|
// template class for arity7 member function type
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6,
|
|
class A7,
|
|
class R> class std_arity7_mf :
|
|
public ObjectType<Object> ,
|
|
public arity7_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
A7,
|
|
R> {
|
|
public:
|
|
typedef R ( __stdcall Object::*pmf7type)(A1, A2, A3, A4, A5, A6, A7);
|
|
};
|
|
|
|
// template class for arity7 member function type
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6,
|
|
class A7,
|
|
class R> class std_arity7_const_mf :
|
|
public ObjectType<Object> ,
|
|
public arity7_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
A7,
|
|
R> {
|
|
public:
|
|
typedef R ( __stdcall Object::*pmf7type)(A1, A2, A3, A4, A5, A6, A7) const;
|
|
};
|
|
|
|
// template class for arity8 member function type
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6,
|
|
class A7,
|
|
class A8,
|
|
class R> class std_arity8_mf :
|
|
public ObjectType<Object> ,
|
|
public arity8_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
A7,
|
|
A8,
|
|
R> {
|
|
public:
|
|
typedef R ( __stdcall Object::*pmf8type)(A1, A2, A3, A4, A5, A6, A7, A8);
|
|
};
|
|
|
|
// template class for arity8 member function type
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6,
|
|
class A7,
|
|
class A8,
|
|
class R> class std_arity8_const_mf :
|
|
public ObjectType<Object> ,
|
|
public arity8_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
A7,
|
|
A8,
|
|
R> {
|
|
public:
|
|
typedef R ( __stdcall Object::*pmf8type)(A1, A2, A3, A4, A5, A6, A7, A8) const;
|
|
};
|
|
|
|
// template class for arity9 member function type
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6,
|
|
class A7,
|
|
class A8,
|
|
class A9,
|
|
class R> class std_arity9_mf :
|
|
public ObjectType<Object> ,
|
|
public arity9_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
A7,
|
|
A8,
|
|
A9,
|
|
R> {
|
|
public:
|
|
typedef R ( __stdcall Object::*pmf9type)(A1, A2, A3, A4, A5, A6, A7, A8, A9);
|
|
};
|
|
|
|
// template class for arity9 member function type
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6,
|
|
class A7,
|
|
class A8,
|
|
class A9,
|
|
class R> class std_arity9_const_mf :
|
|
public ObjectType<Object> ,
|
|
public arity9_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
A7,
|
|
A8,
|
|
A9,
|
|
R> {
|
|
public:
|
|
typedef R ( __stdcall Object::*pmf9type)(A1, A2, A3, A4, A5, A6, A7, A8, A9) const;
|
|
};
|
|
|
|
// template class for arity10 member function type
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6,
|
|
class A7,
|
|
class A8,
|
|
class A9,
|
|
class A10,
|
|
class R> class std_arity10_mf :
|
|
public ObjectType<Object> ,
|
|
public arity10_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
A7,
|
|
A8,
|
|
A9,
|
|
A10,
|
|
R> {
|
|
public:
|
|
typedef R ( __stdcall Object::*pmf10type)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);
|
|
};
|
|
|
|
// template class for arity10 member function type
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6,
|
|
class A7,
|
|
class A8,
|
|
class A9,
|
|
class A10,
|
|
class R> class std_arity10_const_mf :
|
|
public ObjectType<Object> ,
|
|
public arity10_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
A7,
|
|
A8,
|
|
A9,
|
|
A10,
|
|
R> {
|
|
public:
|
|
typedef R ( __stdcall Object::*pmf10type)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) const;
|
|
};
|
|
|
|
// template class for arity11 member function type
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6,
|
|
class A7,
|
|
class A8,
|
|
class A9,
|
|
class A10,
|
|
class A11,
|
|
class R> class std_arity11_mf :
|
|
public ObjectType<Object> ,
|
|
public arity11_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
A7,
|
|
A8,
|
|
A9,
|
|
A10,
|
|
A11,
|
|
R> {
|
|
public:
|
|
typedef R ( __stdcall Object::*pmf11type)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11);
|
|
};
|
|
|
|
// template class for arity11 member function type
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6,
|
|
class A7,
|
|
class A8,
|
|
class A9,
|
|
class A10,
|
|
class A11,
|
|
class R> class std_arity11_const_mf :
|
|
public ObjectType<Object> ,
|
|
public arity11_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
A7,
|
|
A8,
|
|
A9,
|
|
A10,
|
|
A11,
|
|
R> {
|
|
public:
|
|
typedef R ( __stdcall Object::*pmf11type)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) const;
|
|
};
|
|
|
|
// template class for arity12 member function type
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6,
|
|
class A7,
|
|
class A8,
|
|
class A9,
|
|
class A10,
|
|
class A11,
|
|
class A12,
|
|
class R> class std_arity12_mf :
|
|
public ObjectType<Object> ,
|
|
public arity12_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
A7,
|
|
A8,
|
|
A9,
|
|
A10,
|
|
A11,
|
|
A12,
|
|
R> {
|
|
public:
|
|
typedef R ( __stdcall Object::*pmf12type)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12);
|
|
};
|
|
|
|
// template class for arity12 member function type
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6,
|
|
class A7,
|
|
class A8,
|
|
class A9,
|
|
class A10,
|
|
class A11,
|
|
class A12,
|
|
class R> class std_arity12_const_mf :
|
|
public ObjectType<Object> ,
|
|
public arity12_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
A7,
|
|
A8,
|
|
A9,
|
|
A10,
|
|
A11,
|
|
A12,
|
|
R> {
|
|
public:
|
|
typedef R ( __stdcall Object::*pmf12type)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) const;
|
|
};
|
|
|
|
// template class for arity13 member function type
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6,
|
|
class A7,
|
|
class A8,
|
|
class A9,
|
|
class A10,
|
|
class A11,
|
|
class A12,
|
|
class A13,
|
|
class R> class std_arity13_mf :
|
|
public ObjectType<Object> ,
|
|
public arity13_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
A7,
|
|
A8,
|
|
A9,
|
|
A10,
|
|
A11,
|
|
A12,
|
|
A13,
|
|
R> {
|
|
public:
|
|
typedef R ( __stdcall Object::*pmf13type)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13);
|
|
};
|
|
|
|
// template class for arity13 member function type
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6,
|
|
class A7,
|
|
class A8,
|
|
class A9,
|
|
class A10,
|
|
class A11,
|
|
class A12,
|
|
class A13,
|
|
class R> class std_arity13_const_mf :
|
|
public ObjectType<Object> ,
|
|
public arity13_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
A7,
|
|
A8,
|
|
A9,
|
|
A10,
|
|
A11,
|
|
A12,
|
|
A13,
|
|
R> {
|
|
public:
|
|
typedef R ( __stdcall Object::*pmf13type)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) const;
|
|
};
|
|
|
|
// template class for arity14 member function type
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6,
|
|
class A7,
|
|
class A8,
|
|
class A9,
|
|
class A10,
|
|
class A11,
|
|
class A12,
|
|
class A13,
|
|
class A14,
|
|
class R> class std_arity14_mf :
|
|
public ObjectType<Object> ,
|
|
public arity14_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
A7,
|
|
A8,
|
|
A9,
|
|
A10,
|
|
A11,
|
|
A12,
|
|
A13,
|
|
A14,
|
|
R> {
|
|
public:
|
|
typedef R ( __stdcall Object::*pmf14type)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14);
|
|
};
|
|
|
|
// template class for arity14 member function type
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6,
|
|
class A7,
|
|
class A8,
|
|
class A9,
|
|
class A10,
|
|
class A11,
|
|
class A12,
|
|
class A13,
|
|
class A14,
|
|
class R> class std_arity14_const_mf :
|
|
public ObjectType<Object> ,
|
|
public arity14_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
A7,
|
|
A8,
|
|
A9,
|
|
A10,
|
|
A11,
|
|
A12,
|
|
A13,
|
|
A14,
|
|
R> {
|
|
public:
|
|
typedef R ( __stdcall Object::*pmf14type)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) const;
|
|
};
|
|
|
|
// template class for arity15 member function type
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6,
|
|
class A7,
|
|
class A8,
|
|
class A9,
|
|
class A10,
|
|
class A11,
|
|
class A12,
|
|
class A13,
|
|
class A14,
|
|
class A15,
|
|
class R> class std_arity15_mf :
|
|
public ObjectType<Object> ,
|
|
public arity15_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
A7,
|
|
A8,
|
|
A9,
|
|
A10,
|
|
A11,
|
|
A12,
|
|
A13,
|
|
A14,
|
|
A15,
|
|
R> {
|
|
public:
|
|
typedef R ( __stdcall Object::*pmf15type)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15);
|
|
};
|
|
|
|
// template class for arity15 member function type
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6,
|
|
class A7,
|
|
class A8,
|
|
class A9,
|
|
class A10,
|
|
class A11,
|
|
class A12,
|
|
class A13,
|
|
class A14,
|
|
class A15,
|
|
class R> class std_arity15_const_mf :
|
|
public ObjectType<Object> ,
|
|
public arity15_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
A7,
|
|
A8,
|
|
A9,
|
|
A10,
|
|
A11,
|
|
A12,
|
|
A13,
|
|
A14,
|
|
A15,
|
|
R> {
|
|
public:
|
|
typedef R ( __stdcall Object::*pmf15type)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) const;
|
|
};
|
|
|
|
|
|
///////////////////////////////////////////
|
|
// Storage
|
|
///////////////////////////////////////////
|
|
// Template Class for object storage
|
|
template<class Object> class store_object {
|
|
public:
|
|
explicit inline store_object(Object objinit) : objval(objinit) {}
|
|
inline store_object(const store_object &init) : objval(init.objval) {}
|
|
protected:
|
|
Object objval;
|
|
};
|
|
|
|
|
|
// storage allocation classes for arity 0
|
|
|
|
// Template Class for arity 0 function ptr storage
|
|
template<class R> class arity0fp:
|
|
public arity0_function<R> {
|
|
public:
|
|
typedef R (*const pf0type) ();
|
|
explicit inline arity0fp(pf0type pfi) :
|
|
pf0(pfi) {}
|
|
inline arity0fp(const arity0fp& fi) :
|
|
pf0(fi.pf0) {}
|
|
inline R operator()() const {
|
|
return pf0();
|
|
}
|
|
pf0type pf0;
|
|
};
|
|
|
|
// Template Function for arity 0 function ptr storage
|
|
template<class R> inline arity0fp<R>
|
|
arity0_pointer(R (*const pfi)()) {
|
|
return arity0fp<R>(pfi);
|
|
};
|
|
|
|
|
|
// Template Class for arity 0 pmf storage
|
|
template<class Object, class R> class arity0pmf:
|
|
public arity0_mf<Object, R> {
|
|
public:
|
|
typedef arity0_mf<Object, R>::object_type object_type;
|
|
explicit inline arity0pmf(pmf0type pmfi) :
|
|
pmf0(pmfi) {}
|
|
inline arity0pmf(const arity0pmf& pmfi) : pmf0(pmfi.pmf0) {}
|
|
inline virtual R operator()(Object& o ) const {
|
|
return (o.*pmf0)();
|
|
}
|
|
pmf0type pmf0;
|
|
};
|
|
|
|
template<class Object, class R> class arity0pmf_ptr:
|
|
public arity0pmf<Object, R>, public std::unary_function<Object, R> {
|
|
public:
|
|
explicit inline arity0pmf_ptr(pmf0type pmfi) : arity0pmf<Object, R>(pmfi) {}
|
|
inline arity0pmf_ptr(const arity0pmf_ptr& pmfi) : arity0pmf<Object, R>(pmfi) {}
|
|
inline virtual R operator()(Object& o ) const {
|
|
return (o.*pmf0)();
|
|
}
|
|
inline virtual R operator()(Object* o ) const {
|
|
return (o->*pmf0)();
|
|
}
|
|
};
|
|
|
|
// Template Function for arity 0 pmf storage
|
|
template<class Object, class R> inline arity0pmf_ptr<Object, R>
|
|
arity0_member_ptr(R (Object::*const pmfi)()) {
|
|
return arity0pmf_ptr<Object, R>(pmfi);
|
|
};
|
|
|
|
// Template Function for arity 0 pmf storage
|
|
template<class Object, class R> inline arity0pmf<Object, R>
|
|
arity0_member(R (Object::*const pmfi)()) {
|
|
return arity0pmf<Object, R>(pmfi);
|
|
};
|
|
|
|
|
|
// Template Class for arity 0 const pmf storage
|
|
template<class Object, class R> class arity0pmf_const:
|
|
public arity0_const_mf<const Object, R> {
|
|
public:
|
|
typedef arity0_const_mf<const Object, R>::object_type object_type;
|
|
explicit inline arity0pmf_const(pmf0type pmfi) :
|
|
pmf0(pmfi) {}
|
|
inline arity0pmf_const(const arity0pmf_const& pmfi) : pmf0(pmfi.pmf0) {}
|
|
inline virtual R operator()(const Object& o ) const {
|
|
return (o.*pmf0)();
|
|
}
|
|
pmf0type pmf0;
|
|
};
|
|
|
|
// Template Function for arity 0 const pmf storage
|
|
template<const class Object, class R> inline arity0pmf_const<const Object, R>
|
|
arity0_const_member(R (Object::*const pmfi)() const) {
|
|
return arity0pmf_const<const Object, R>(pmfi);
|
|
};
|
|
|
|
|
|
// Template Class for arity 0 obj&pmf ref storage
|
|
template<class Function> class arity0opmf:
|
|
public arity0pmf<Function::object_type, Function::result_type>,
|
|
public store_object<Function::object_type&> {
|
|
public:
|
|
explicit inline arity0opmf(Function::object_type& oi, const Function &f) :
|
|
store_object<Function::object_type&>(oi), arity0pmf<Function::object_type, Function::result_type>(f) {}
|
|
explicit inline arity0opmf(Function::object_type& oi, pmf0type pmfi) :
|
|
store_object<Function::object_type&>(oi), arity0pmf<Function::object_type, Function::result_type>(pmfi) {}
|
|
inline arity0opmf(const arity0opmf& bndri) :
|
|
store_object<Function::object_type&>(bndri), arity0pmf<Function::object_type, Function::result_type>(bndri) {}
|
|
inline Function::result_type operator()() const {
|
|
return (objval.*pmf0)();
|
|
}
|
|
pmf0type pmf0;
|
|
};
|
|
|
|
|
|
// Template Function for arity 0 obj&pmf ref storage
|
|
template<class Function, class Object> inline arity0opmf<Function>
|
|
arity0_member_obj(Object& oi, const Function &f) {
|
|
return arity0opmf<Function>(Function::object_type(oi), Function::pmf0type(f.pmf0));
|
|
};
|
|
|
|
|
|
// Template Class for arity 0 const obj&pmf ref storage
|
|
template<class Function> class arity0opmf_const:
|
|
public arity0pmf_const<const Function::object_type, Function::result_type>,
|
|
public store_object<const Function::object_type&> {
|
|
public:
|
|
explicit inline arity0opmf_const(Function::object_type& oi, const Function &f) :
|
|
store_object<Function::object_type&>(oi), arity0pmf_const<Function::object_type, Function::result_type>(f) {}
|
|
explicit inline arity0opmf_const(Function::object_type& oi, pmf0type pmfi) :
|
|
store_object<Function::object_type&>(oi), arity0pmf_const<Function::object_type, Function::result_type>(pmfi) {}
|
|
inline arity0opmf_const(const arity0opmf_const& bndri) :
|
|
store_object<Function::object_type&>(bndri), arity0pmf_const<Function::object_type, Function::result_type>(bndri) {}
|
|
inline Function::result_type operator()() const {
|
|
return (objval.*pmf0)();
|
|
}
|
|
pmf0type pmf0;
|
|
};
|
|
|
|
|
|
// Template Function for arity 0 const obj&pmf ref storage
|
|
template<class Function, class Object> inline arity0opmf_const<Function>
|
|
arity0_const_member_obj(Object& oi, const Function &f) {
|
|
return arity0opmf_const<Function>(Function::object_type(oi), Function::pmf0type(f.pmf0));
|
|
};
|
|
|
|
|
|
|
|
// storage allocation classes for arity 1
|
|
|
|
// Template Class for arity 1 function ptr storage
|
|
template<class A1,
|
|
class R> class arity1fp:
|
|
public std::unary_function<A1,
|
|
R>,
|
|
public arity0fp<R> {
|
|
public:
|
|
typedef std::unary_function<A1,
|
|
R>::result_type result_type;
|
|
typedef R (*const pf1type) (A1);
|
|
explicit inline arity1fp(pf1type pfi) :
|
|
arity0fp<R>(reinterpret_cast<pf0type>(pfi)) {}
|
|
inline arity1fp(const arity1fp& fi) :
|
|
arity0fp<R>(fi) {}
|
|
inline R operator()(A1 a1) const {
|
|
pf1type pf = reinterpret_cast<pf1type>(pf0);
|
|
return pf(a1);
|
|
}
|
|
};
|
|
|
|
// Template Function for arity 1 function ptr storage
|
|
template<class A1,
|
|
class R> inline arity1fp<A1,
|
|
R>
|
|
arity1_pointer(R (*const pfi)(A1)) {
|
|
return arity1fp<A1,
|
|
R>(pfi);
|
|
};
|
|
|
|
|
|
// Template Class for arity 1 pmf storage
|
|
template<class Object,
|
|
class A1,
|
|
class R> class arity1pmf:
|
|
public arity1_mf<Object,
|
|
A1,
|
|
R>,
|
|
public arity0pmf<Object, R> {
|
|
public:
|
|
typedef std::unary_function<A1,
|
|
R>::result_type result_type;
|
|
typedef arity1_mf<Object,
|
|
A1,
|
|
R>::object_type object_type;
|
|
explicit inline arity1pmf(pmf1type pmfi) :
|
|
arity0pmf<Object, R>(reinterpret_cast<pmf0type>(pmfi)) {}
|
|
inline arity1pmf(const arity1pmf& pmfi) : arity0pmf<Object, R>(pmfi) {}
|
|
inline virtual R operator()(Object& o, A1 a1) const {
|
|
pmf1type pmf = reinterpret_cast<pmf1type>(pmf0);
|
|
return (o.*pmf)(a1);
|
|
}
|
|
};
|
|
|
|
// Template Function for arity 1 pmf storage
|
|
template<class Object,
|
|
class A1,
|
|
class R> inline arity1pmf<Object,
|
|
A1,
|
|
R>
|
|
arity1_member(R (Object::*const pmfi)(A1)) {
|
|
return arity1pmf<Object,
|
|
A1,
|
|
R>(pmfi);
|
|
};
|
|
|
|
|
|
// Template Class for arity 1 const pmf storage
|
|
template<class Object,
|
|
class A1,
|
|
class R> class arity1pmf_const:
|
|
public arity1_const_mf<const Object,
|
|
A1,
|
|
R>,
|
|
public arity0pmf_const<const Object, R> {
|
|
public:
|
|
typedef std::unary_function<A1,
|
|
R>::result_type result_type;
|
|
typedef arity1_const_mf<const Object,
|
|
A1,
|
|
R>::object_type object_type;
|
|
explicit inline arity1pmf_const(pmf1type pmfi) :
|
|
arity0pmf_const<const Object, R>(reinterpret_cast<pmf0type>(pmfi)) {}
|
|
inline arity1pmf_const(const arity1pmf_const& pmfi) : arity0pmf_const<Object, R>(pmfi) {}
|
|
inline virtual R operator()(const Object& o, A1 a1) const {
|
|
pmf1type pmf = reinterpret_cast<pmf1type>(pmf0);
|
|
return (o.*pmf)(a1);
|
|
}
|
|
};
|
|
|
|
// Template Function for arity 1 const pmf storage
|
|
template<const class Object,
|
|
class A1,
|
|
class R> inline arity1pmf_const<const Object,
|
|
A1,
|
|
R>
|
|
arity1_const_member(R (Object::*const pmfi)(A1) const) {
|
|
return arity1pmf_const<const Object,
|
|
A1,
|
|
R>(pmfi);
|
|
};
|
|
|
|
|
|
// Template Class for arity 1 obj&pmf ref storage
|
|
template<class Function> class arity1opmf:
|
|
public arity1pmf<Function::object_type,
|
|
Function::argument_type,
|
|
Function::result_type>,
|
|
public store_object<Function::object_type&> {
|
|
public:
|
|
explicit inline arity1opmf(Function::object_type& oi, const Function &f) :
|
|
store_object<Function::object_type&>(oi), arity1pmf<Function::object_type,
|
|
Function::argument_type,
|
|
Function::result_type>(f) {}
|
|
explicit inline arity1opmf(Function::object_type& oi, pmf1type pmfi) :
|
|
store_object<Function::object_type&>(oi), arity1pmf<Function::object_type,
|
|
Function::argument_type,
|
|
Function::result_type>(pmfi) {}
|
|
inline arity1opmf(const arity1opmf& bndri) :
|
|
store_object<Function::object_type&>(bndri), arity1pmf<Function::object_type,
|
|
Function::argument_type,
|
|
Function::result_type>(bndri) {}
|
|
inline Function::result_type operator()(Function::argument_type a1) const {
|
|
pmf1type pmf = reinterpret_cast<pmf1type>(pmf0);
|
|
return (objval.*pmf)(a1);
|
|
}
|
|
};
|
|
|
|
|
|
// Template Function for arity 1 obj&pmf ref storage
|
|
template<class Function, class Object> inline arity1opmf<Function>
|
|
arity1_member_obj(Object& oi, const Function &f) {
|
|
return arity1opmf<Function>(Function::object_type(oi), Function::pmf1type(f.pmf0));
|
|
};
|
|
|
|
|
|
// Template Class for arity 1 const obj&pmf ref storage
|
|
template<class Function> class arity1opmf_const:
|
|
public arity1pmf_const<const Function::object_type,
|
|
Function::argument_type,
|
|
Function::result_type>,
|
|
public store_object<const Function::object_type&> {
|
|
public:
|
|
explicit inline arity1opmf_const(Function::object_type& oi, const Function &f) :
|
|
store_object<Function::object_type&>(oi), arity1pmf_const<Function::object_type,
|
|
Function::argument_type,
|
|
Function::result_type>(f) {}
|
|
explicit inline arity1opmf_const(Function::object_type& oi, pmf1type pmfi) :
|
|
store_object<Function::object_type&>(oi), arity1pmf_const<Function::object_type,
|
|
Function::argument_type,
|
|
Function::result_type>(pmfi) {}
|
|
inline arity1opmf_const(const arity1opmf_const& bndri) :
|
|
store_object<Function::object_type&>(bndri), arity1pmf_const<Function::object_type,
|
|
Function::argument_type,
|
|
Function::result_type>(bndri) {}
|
|
inline Function::result_type operator()(Function::argument_type a1) const {
|
|
pmf1type pmf = reinterpret_cast<pmf1type>(pmf0);
|
|
return (objval.*pmf)(a1);
|
|
}
|
|
};
|
|
|
|
|
|
// Template Function for arity 1 const obj&pmf ref storage
|
|
template<class Function, class Object> inline arity1opmf_const<Function>
|
|
arity1_const_member_obj(Object& oi, const Function &f) {
|
|
return arity1opmf_const<Function>(Function::object_type(oi), Function::pmf1type(f.pmf0));
|
|
};
|
|
|
|
|
|
|
|
// storage allocation classes for arity 2
|
|
|
|
// Template Class for arity 2 function ptr storage
|
|
template<class A1,
|
|
class A2,
|
|
class R> class arity2fp:
|
|
public std::binary_function<A1,
|
|
A2,
|
|
R>,
|
|
public arity0fp<R> {
|
|
public:
|
|
typedef std::binary_function<A1,
|
|
A2,
|
|
R>::result_type result_type;
|
|
typedef std::binary_function<A1,
|
|
A2,
|
|
R>::first_argument_type first_argument_type;
|
|
typedef R (*const pf2type) (A1, A2);
|
|
explicit inline arity2fp(pf2type pfi) :
|
|
arity0fp<R>(reinterpret_cast<pf0type>(pfi)) {}
|
|
inline arity2fp(const arity2fp& fi) :
|
|
arity0fp<R>(fi) {}
|
|
inline R operator()(A1 a1,
|
|
A2 a2) const {
|
|
pf2type pf = reinterpret_cast<pf2type>(pf0);
|
|
return pf(a1, a2);
|
|
}
|
|
};
|
|
|
|
// Template Function for arity 2 function ptr storage
|
|
template<class A1,
|
|
class A2,
|
|
class R> inline arity2fp<A1,
|
|
A2,
|
|
R>
|
|
arity2_pointer(R (*const pfi)(A1,
|
|
A2)) {
|
|
return arity2fp<A1,
|
|
A2,
|
|
R>(pfi);
|
|
};
|
|
|
|
// Template Class for arity 2 pmf storage
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class R> class arity2pmf:
|
|
public arity2_mf<Object,
|
|
A1,
|
|
A2,
|
|
R>,
|
|
public arity0pmf<Object, R> {
|
|
public:
|
|
typedef std::binary_function<A1,
|
|
A2,
|
|
R>::result_type result_type;
|
|
typedef std::binary_function<A1,
|
|
A2,
|
|
R>::first_argument_type first_argument_type;
|
|
typedef arity2_mf<Object,
|
|
A1,
|
|
A2,
|
|
R>::object_type object_type;
|
|
explicit inline arity2pmf(pmf2type pmfi) :
|
|
arity0pmf<Object, R>(reinterpret_cast<pmf0type>(pmfi)) {}
|
|
inline arity2pmf(const arity2pmf& pmfi) : arity0pmf<Object, R>(pmfi) {}
|
|
inline virtual R operator()(Object& o, A1 a1,
|
|
A2 a2) const {
|
|
pmf2type pmf = reinterpret_cast<pmf2type>(pmf0);
|
|
return (o.*pmf)(a1, a2);
|
|
}
|
|
};
|
|
|
|
// Template Function for arity 2 pmf storage
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class R> inline arity2pmf<Object,
|
|
A1,
|
|
A2,
|
|
R>
|
|
arity2_member(R (Object::*const pmfi)(A1,
|
|
A2)) {
|
|
return arity2pmf<Object,
|
|
A1,
|
|
A2,
|
|
R>(pmfi);
|
|
};
|
|
|
|
|
|
// Template Class for arity 2 const pmf storage
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class R> class arity2pmf_const:
|
|
public arity2_const_mf<const Object,
|
|
A1,
|
|
A2,
|
|
R>,
|
|
public arity0pmf_const<const Object, R> {
|
|
public:
|
|
typedef std::binary_function<A1,
|
|
A2,
|
|
R>::result_type result_type;
|
|
typedef std::binary_function<A1,
|
|
A2,
|
|
R>::first_argument_type first_argument_type;
|
|
typedef arity2_const_mf<const Object,
|
|
A1,
|
|
A2,
|
|
R>::object_type object_type;
|
|
explicit inline arity2pmf_const(pmf2type pmfi) :
|
|
arity0pmf_const<const Object, R>(reinterpret_cast<pmf0type>(pmfi)) {}
|
|
inline arity2pmf_const(const arity2pmf_const& pmfi) : arity0pmf_const<Object, R>(pmfi) {}
|
|
inline virtual R operator()(const Object& o, A1 a1,
|
|
A2 a2) const {
|
|
pmf2type pmf = reinterpret_cast<pmf2type>(pmf0);
|
|
return (o.*pmf)(a1, a2);
|
|
}
|
|
};
|
|
|
|
// Template Function for arity 2 const pmf storage
|
|
template<const class Object,
|
|
class A1,
|
|
class A2,
|
|
class R> inline arity2pmf_const<const Object,
|
|
A1,
|
|
A2,
|
|
R>
|
|
arity2_const_member(R (Object::*const pmfi)(A1,
|
|
A2) const) {
|
|
return arity2pmf_const<const Object,
|
|
A1,
|
|
A2,
|
|
R>(pmfi);
|
|
};
|
|
|
|
// Template Class for arity 2 obj&pmf ref storage
|
|
template<class Function> class arity2opmf:
|
|
public arity2pmf<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::result_type>,
|
|
public store_object<Function::object_type&> {
|
|
public:
|
|
explicit inline arity2opmf(Function::object_type& oi, const Function &f) :
|
|
store_object<Function::object_type&>(oi), arity2pmf<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::result_type>(f) {}
|
|
explicit inline arity2opmf(Function::object_type& oi, pmf2type pmfi) :
|
|
store_object<Function::object_type&>(oi), arity2pmf<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::result_type>(pmfi) {}
|
|
inline arity2opmf(const arity2opmf& bndri) :
|
|
store_object<Function::object_type&>(bndri), arity2pmf<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::result_type>(bndri) {}
|
|
inline Function::result_type operator()(Function::first_argument_type a1,
|
|
Function::second_argument_type a2) const {
|
|
pmf2type pmf = reinterpret_cast<pmf2type>(pmf0);
|
|
return (objval.*pmf)(a1, a2);
|
|
}
|
|
};
|
|
|
|
|
|
// Template Function for arity 2 obj&pmf ref storage
|
|
template<class Function, class Object> inline arity2opmf<Function>
|
|
arity2_member_obj(Object& oi, const Function &f) {
|
|
return arity2opmf<Function>(Function::object_type(oi), Function::pmf2type(f.pmf0));
|
|
};
|
|
|
|
|
|
// Template Class for arity 2 const obj&pmf ref storage
|
|
template<class Function> class arity2opmf_const:
|
|
public arity2pmf_const<const Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::result_type>,
|
|
public store_object<const Function::object_type&> {
|
|
public:
|
|
explicit inline arity2opmf_const(Function::object_type& oi, const Function &f) :
|
|
store_object<Function::object_type&>(oi), arity2pmf_const<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::result_type>(f) {}
|
|
explicit inline arity2opmf_const(Function::object_type& oi, pmf2type pmfi) :
|
|
store_object<Function::object_type&>(oi), arity2pmf_const<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::result_type>(pmfi) {}
|
|
inline arity2opmf_const(const arity2opmf_const& bndri) :
|
|
store_object<Function::object_type&>(bndri), arity2pmf_const<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::result_type>(bndri) {}
|
|
inline Function::result_type operator()(Function::first_argument_type a1,
|
|
Function::second_argument_type a2) const {
|
|
pmf2type pmf = reinterpret_cast<pmf2type>(pmf0);
|
|
return (objval.*pmf)(a1, a2);
|
|
}
|
|
};
|
|
|
|
|
|
// Template Function for arity 2 const obj&pmf ref storage
|
|
template<class Function, class Object> inline arity2opmf_const<Function>
|
|
arity2_const_member_obj(Object& oi, const Function &f) {
|
|
return arity2opmf_const<Function>(Function::object_type(oi), Function::pmf2type(f.pmf0));
|
|
};
|
|
|
|
|
|
|
|
// storage allocation classes for arity 3
|
|
|
|
// Template Class for arity 3 function ptr storage
|
|
template<class A1,
|
|
class A2,
|
|
class A3,
|
|
class R> class arity3fp:
|
|
public arity3_function<A1,
|
|
A2,
|
|
A3,
|
|
R>,
|
|
public arity0fp<R> {
|
|
public:
|
|
typedef arity3_function<A1,
|
|
A2,
|
|
A3,
|
|
R>::result_type result_type;
|
|
typedef arity3_function<A1,
|
|
A2,
|
|
A3,
|
|
R>::first_argument_type first_argument_type;
|
|
typedef arity3_function<A1,
|
|
A2,
|
|
A3,
|
|
R>::second_argument_type second_argument_type;
|
|
typedef R (*const pf3type) (A1, A2, A3);
|
|
explicit inline arity3fp(pf3type pfi) :
|
|
arity0fp<R>(reinterpret_cast<pf0type>(pfi)) {}
|
|
inline arity3fp(const arity3fp& fi) :
|
|
arity0fp<R>(fi) {}
|
|
inline R operator()(A1 a1,
|
|
A2 a2,
|
|
A3 a3) const {
|
|
pf3type pf = reinterpret_cast<pf3type>(pf0);
|
|
return pf(a1, a2, a3);
|
|
}
|
|
};
|
|
|
|
// Template Function for arity 3 function ptr storage
|
|
template<class A1,
|
|
class A2,
|
|
class A3,
|
|
class R> inline arity3fp<A1,
|
|
A2,
|
|
A3,
|
|
R>
|
|
arity3_pointer(R (*const pfi)(A1,
|
|
A2,
|
|
A3)) {
|
|
return arity3fp<A1,
|
|
A2,
|
|
A3,
|
|
R>(pfi);
|
|
};
|
|
|
|
|
|
// Template Class for arity 3 pmf storage
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class R> class arity3pmf:
|
|
public arity3_mf<Object,
|
|
A1,
|
|
A2,
|
|
A3,
|
|
R>,
|
|
public arity0pmf<Object, R> {
|
|
public:
|
|
typedef arity3_function<A1,
|
|
A2,
|
|
A3,
|
|
R>::result_type result_type;
|
|
typedef arity3_function<A1,
|
|
A2,
|
|
A3,
|
|
R>::first_argument_type first_argument_type;
|
|
typedef arity3_function<A1,
|
|
A2,
|
|
A3,
|
|
R>::second_argument_type second_argument_type;
|
|
typedef arity3_mf<Object,
|
|
A1,
|
|
A2,
|
|
A3,
|
|
R>::object_type object_type;
|
|
explicit inline arity3pmf(pmf3type pmfi) :
|
|
arity0pmf<Object, R>(reinterpret_cast<pmf0type>(pmfi)) {}
|
|
inline arity3pmf(const arity3pmf& pmfi) : arity0pmf<Object, R>(pmfi) {}
|
|
inline virtual R operator()(Object& o, A1 a1,
|
|
A2 a2,
|
|
A3 a3) const {
|
|
pmf3type pmf = reinterpret_cast<pmf3type>(pmf0);
|
|
return (o.*pmf)(a1, a2, a3);
|
|
}
|
|
};
|
|
|
|
// Template Function for arity 3 pmf storage
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class R> inline arity3pmf<Object,
|
|
A1,
|
|
A2,
|
|
A3,
|
|
R>
|
|
arity3_member(R (Object::*const pmfi)(A1,
|
|
A2,
|
|
A3)) {
|
|
return arity3pmf<Object,
|
|
A1,
|
|
A2,
|
|
A3,
|
|
R>(pmfi);
|
|
};
|
|
|
|
|
|
// Template Class for arity 3 const pmf storage
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class R> class arity3pmf_const:
|
|
public arity3_const_mf<const Object,
|
|
A1,
|
|
A2,
|
|
A3,
|
|
R>,
|
|
public arity0pmf_const<const Object, R> {
|
|
public:
|
|
typedef arity3_function<A1,
|
|
A2,
|
|
A3,
|
|
R>::result_type result_type;
|
|
typedef arity3_function<A1,
|
|
A2,
|
|
A3,
|
|
R>::first_argument_type first_argument_type;
|
|
typedef arity3_function<A1,
|
|
A2,
|
|
A3,
|
|
R>::second_argument_type second_argument_type;
|
|
typedef arity3_const_mf<const Object,
|
|
A1,
|
|
A2,
|
|
A3,
|
|
R>::object_type object_type;
|
|
explicit inline arity3pmf_const(pmf3type pmfi) :
|
|
arity0pmf_const<const Object, R>(reinterpret_cast<pmf0type>(pmfi)) {}
|
|
inline arity3pmf_const(const arity3pmf_const& pmfi) : arity0pmf_const<Object, R>(pmfi) {}
|
|
inline virtual R operator()(const Object& o, A1 a1,
|
|
A2 a2,
|
|
A3 a3) const {
|
|
pmf3type pmf = reinterpret_cast<pmf3type>(pmf0);
|
|
return (o.*pmf)(a1, a2, a3);
|
|
}
|
|
};
|
|
|
|
// Template Function for arity 3 const pmf storage
|
|
template<const class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class R> inline arity3pmf_const<const Object,
|
|
A1,
|
|
A2,
|
|
A3,
|
|
R>
|
|
arity3_const_member(R (Object::*const pmfi)(A1,
|
|
A2,
|
|
A3) const) {
|
|
return arity3pmf_const<const Object,
|
|
A1,
|
|
A2,
|
|
A3,
|
|
R>(pmfi);
|
|
};
|
|
|
|
|
|
// Template Class for arity 3 obj&pmf ref storage
|
|
template<class Function> class arity3opmf:
|
|
public arity3pmf<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::result_type>,
|
|
public store_object<Function::object_type&> {
|
|
public:
|
|
explicit inline arity3opmf(Function::object_type& oi, const Function &f) :
|
|
store_object<Function::object_type&>(oi), arity3pmf<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::result_type>(f) {}
|
|
explicit inline arity3opmf(Function::object_type& oi, pmf3type pmfi) :
|
|
store_object<Function::object_type&>(oi), arity3pmf<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::result_type>(pmfi) {}
|
|
inline arity3opmf(const arity3opmf& bndri) :
|
|
store_object<Function::object_type&>(bndri), arity3pmf<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::result_type>(bndri) {}
|
|
inline Function::result_type operator()(Function::first_argument_type a1,
|
|
Function::second_argument_type a2,
|
|
Function::argument_3_type a3) const {
|
|
pmf3type pmf = reinterpret_cast<pmf3type>(pmf0);
|
|
return (objval.*pmf)(a1, a2, a3);
|
|
}
|
|
};
|
|
|
|
|
|
// Template Function for arity 3 obj&pmf ref storage
|
|
template<class Function, class Object> inline arity3opmf<Function>
|
|
arity3_member_obj(Object& oi, const Function &f) {
|
|
return arity3opmf<Function>(Function::object_type(oi), Function::pmf3type(f.pmf0));
|
|
};
|
|
|
|
|
|
// Template Class for arity 3 const obj&pmf ref storage
|
|
template<class Function> class arity3opmf_const:
|
|
public arity3pmf_const<const Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::result_type>,
|
|
public store_object<const Function::object_type&> {
|
|
public:
|
|
explicit inline arity3opmf_const(Function::object_type& oi, const Function &f) :
|
|
store_object<Function::object_type&>(oi), arity3pmf_const<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::result_type>(f) {}
|
|
explicit inline arity3opmf_const(Function::object_type& oi, pmf3type pmfi) :
|
|
store_object<Function::object_type&>(oi), arity3pmf_const<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::result_type>(pmfi) {}
|
|
inline arity3opmf_const(const arity3opmf_const& bndri) :
|
|
store_object<Function::object_type&>(bndri), arity3pmf_const<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::result_type>(bndri) {}
|
|
inline Function::result_type operator()(Function::first_argument_type a1,
|
|
Function::second_argument_type a2,
|
|
Function::argument_3_type a3) const {
|
|
pmf3type pmf = reinterpret_cast<pmf3type>(pmf0);
|
|
return (objval.*pmf)(a1, a2, a3);
|
|
}
|
|
};
|
|
|
|
|
|
// Template Function for arity 3 const obj&pmf ref storage
|
|
template<class Function, class Object> inline arity3opmf_const<Function>
|
|
arity3_const_member_obj(Object& oi, const Function &f) {
|
|
return arity3opmf_const<Function>(Function::object_type(oi), Function::pmf3type(f.pmf0));
|
|
};
|
|
|
|
|
|
|
|
// storage allocation classes for arity 4
|
|
|
|
// Template Class for arity 4 pmf storage
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class R> class arity4pmf:
|
|
public arity4_mf<Object,
|
|
A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
R>,
|
|
public arity0pmf<Object, R> {
|
|
public:
|
|
typedef arity4_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
R>::result_type result_type;
|
|
typedef arity4_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
R>::first_argument_type first_argument_type;
|
|
typedef arity4_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
R>::second_argument_type second_argument_type;
|
|
typedef arity4_mf<Object,
|
|
A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
R>::object_type object_type;
|
|
explicit inline arity4pmf(pmf4type pmfi) :
|
|
arity0pmf<Object, R>(reinterpret_cast<pmf0type>(pmfi)) {}
|
|
inline arity4pmf(const arity4pmf& pmfi) : arity0pmf<Object, R>(pmfi) {}
|
|
inline virtual R operator()(Object& o, A1 a1,
|
|
A2 a2,
|
|
A3 a3,
|
|
A4 a4) const {
|
|
pmf4type pmf = reinterpret_cast<pmf4type>(pmf0);
|
|
return (o.*pmf)(a1, a2, a3, a4);
|
|
}
|
|
};
|
|
|
|
// Template Function for arity 4 pmf storage
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class R> inline arity4pmf<Object,
|
|
A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
R>
|
|
arity4_member(R (Object::*const pmfi)(A1,
|
|
A2,
|
|
A3,
|
|
A4)) {
|
|
return arity4pmf<Object,
|
|
A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
R>(pmfi);
|
|
};
|
|
|
|
|
|
// Template Class for arity 4 const pmf storage
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class R> class arity4pmf_const:
|
|
public arity4_const_mf<const Object,
|
|
A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
R>,
|
|
public arity0pmf_const<const Object, R> {
|
|
public:
|
|
typedef arity4_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
R>::result_type result_type;
|
|
typedef arity4_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
R>::first_argument_type first_argument_type;
|
|
typedef arity4_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
R>::second_argument_type second_argument_type;
|
|
typedef arity4_const_mf<const Object,
|
|
A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
R>::object_type object_type;
|
|
explicit inline arity4pmf_const(pmf4type pmfi) :
|
|
arity0pmf_const<const Object, R>(reinterpret_cast<pmf0type>(pmfi)) {}
|
|
inline arity4pmf_const(const arity4pmf_const& pmfi) : arity0pmf_const<Object, R>(pmfi) {}
|
|
inline virtual R operator()(const Object& o, A1 a1,
|
|
A2 a2,
|
|
A3 a3,
|
|
A4 a4) const {
|
|
pmf4type pmf = reinterpret_cast<pmf4type>(pmf0);
|
|
return (o.*pmf)(a1, a2, a3, a4);
|
|
}
|
|
};
|
|
|
|
// Template Function for arity 4 const pmf storage
|
|
template<const class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class R> inline arity4pmf_const<const Object,
|
|
A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
R>
|
|
arity4_const_member(R (Object::*const pmfi)(A1,
|
|
A2,
|
|
A3,
|
|
A4) const) {
|
|
return arity4pmf_const<const Object,
|
|
A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
R>(pmfi);
|
|
};
|
|
|
|
|
|
// Template Class for arity 4 obj&pmf ref storage
|
|
template<class Function> class arity4opmf:
|
|
public arity4pmf<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::result_type>,
|
|
public store_object<Function::object_type&> {
|
|
public:
|
|
explicit inline arity4opmf(Function::object_type& oi, const Function &f) :
|
|
store_object<Function::object_type&>(oi), arity4pmf<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::result_type>(f) {}
|
|
explicit inline arity4opmf(Function::object_type& oi, pmf4type pmfi) :
|
|
store_object<Function::object_type&>(oi), arity4pmf<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::result_type>(pmfi) {}
|
|
inline arity4opmf(const arity4opmf& bndri) :
|
|
store_object<Function::object_type&>(bndri), arity4pmf<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::result_type>(bndri) {}
|
|
inline Function::result_type operator()(Function::first_argument_type a1,
|
|
Function::second_argument_type a2,
|
|
Function::argument_3_type a3,
|
|
Function::argument_4_type a4) const {
|
|
pmf4type pmf = reinterpret_cast<pmf4type>(pmf0);
|
|
return (objval.*pmf)(a1, a2, a3, a4);
|
|
}
|
|
};
|
|
|
|
|
|
// Template Function for arity 4 obj&pmf ref storage
|
|
template<class Function, class Object> inline arity4opmf<Function>
|
|
arity4_member_obj(Object& oi, const Function &f) {
|
|
return arity4opmf<Function>(Function::object_type(oi), Function::pmf4type(f.pmf0));
|
|
};
|
|
|
|
|
|
// Template Class for arity 4 const obj&pmf ref storage
|
|
template<class Function> class arity4opmf_const:
|
|
public arity4pmf_const<const Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::result_type>,
|
|
public store_object<const Function::object_type&> {
|
|
public:
|
|
explicit inline arity4opmf_const(Function::object_type& oi, const Function &f) :
|
|
store_object<Function::object_type&>(oi), arity4pmf_const<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::result_type>(f) {}
|
|
explicit inline arity4opmf_const(Function::object_type& oi, pmf4type pmfi) :
|
|
store_object<Function::object_type&>(oi), arity4pmf_const<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::result_type>(pmfi) {}
|
|
inline arity4opmf_const(const arity4opmf_const& bndri) :
|
|
store_object<Function::object_type&>(bndri), arity4pmf_const<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::result_type>(bndri) {}
|
|
inline Function::result_type operator()(Function::first_argument_type a1,
|
|
Function::second_argument_type a2,
|
|
Function::argument_3_type a3,
|
|
Function::argument_4_type a4) const {
|
|
pmf4type pmf = reinterpret_cast<pmf4type>(pmf0);
|
|
return (objval.*pmf)(a1, a2, a3, a4);
|
|
}
|
|
};
|
|
|
|
|
|
// Template Function for arity 4 const obj&pmf ref storage
|
|
template<class Function, class Object> inline arity4opmf_const<Function>
|
|
arity4_const_member_obj(Object& oi, const Function &f) {
|
|
return arity4opmf_const<Function>(Function::object_type(oi), Function::pmf4type(f.pmf0));
|
|
};
|
|
|
|
|
|
|
|
// storage allocation classes for arity 5
|
|
|
|
// Template Class for arity 5 pmf storage
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class R> class arity5pmf:
|
|
public arity5_mf<Object,
|
|
A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
R>,
|
|
public arity0pmf<Object, R> {
|
|
public:
|
|
typedef arity5_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
R>::result_type result_type;
|
|
typedef arity5_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
R>::first_argument_type first_argument_type;
|
|
typedef arity5_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
R>::second_argument_type second_argument_type;
|
|
typedef arity5_mf<Object,
|
|
A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
R>::object_type object_type;
|
|
explicit inline arity5pmf(pmf5type pmfi) :
|
|
arity0pmf<Object, R>(reinterpret_cast<pmf0type>(pmfi)) {}
|
|
inline arity5pmf(const arity5pmf& pmfi) : arity0pmf<Object, R>(pmfi) {}
|
|
inline virtual R operator()(Object& o, A1 a1,
|
|
A2 a2,
|
|
A3 a3,
|
|
A4 a4,
|
|
A5 a5) const {
|
|
pmf5type pmf = reinterpret_cast<pmf5type>(pmf0);
|
|
return (o.*pmf)(a1, a2, a3, a4, a5);
|
|
}
|
|
};
|
|
|
|
// Template Function for arity 5 pmf storage
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class R> inline arity5pmf<Object,
|
|
A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
R>
|
|
arity5_member(R (Object::*const pmfi)(A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5)) {
|
|
return arity5pmf<Object,
|
|
A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
R>(pmfi);
|
|
};
|
|
|
|
|
|
// Template Class for arity 5 const pmf storage
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class R> class arity5pmf_const:
|
|
public arity5_const_mf<const Object,
|
|
A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
R>,
|
|
public arity0pmf_const<const Object, R> {
|
|
public:
|
|
typedef arity5_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
R>::result_type result_type;
|
|
typedef arity5_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
R>::first_argument_type first_argument_type;
|
|
typedef arity5_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
R>::second_argument_type second_argument_type;
|
|
typedef arity5_const_mf<const Object,
|
|
A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
R>::object_type object_type;
|
|
explicit inline arity5pmf_const(pmf5type pmfi) :
|
|
arity0pmf_const<const Object, R>(reinterpret_cast<pmf0type>(pmfi)) {}
|
|
inline arity5pmf_const(const arity5pmf_const& pmfi) : arity0pmf_const<Object, R>(pmfi) {}
|
|
inline virtual R operator()(const Object& o, A1 a1,
|
|
A2 a2,
|
|
A3 a3,
|
|
A4 a4,
|
|
A5 a5) const {
|
|
pmf5type pmf = reinterpret_cast<pmf5type>(pmf0);
|
|
return (o.*pmf)(a1, a2, a3, a4, a5);
|
|
}
|
|
};
|
|
|
|
// Template Function for arity 5 const pmf storage
|
|
template<const class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class R> inline arity5pmf_const<const Object,
|
|
A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
R>
|
|
arity5_const_member(R (Object::*const pmfi)(A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5) const) {
|
|
return arity5pmf_const<const Object,
|
|
A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
R>(pmfi);
|
|
};
|
|
|
|
|
|
// Template Class for arity 5 obj&pmf ref storage
|
|
template<class Function> class arity5opmf:
|
|
public arity5pmf<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::result_type>,
|
|
public store_object<Function::object_type&> {
|
|
public:
|
|
explicit inline arity5opmf(Function::object_type& oi, const Function &f) :
|
|
store_object<Function::object_type&>(oi), arity5pmf<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::result_type>(f) {}
|
|
explicit inline arity5opmf(Function::object_type& oi, pmf5type pmfi) :
|
|
store_object<Function::object_type&>(oi), arity5pmf<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::result_type>(pmfi) {}
|
|
inline arity5opmf(const arity5opmf& bndri) :
|
|
store_object<Function::object_type&>(bndri), arity5pmf<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::result_type>(bndri) {}
|
|
inline Function::result_type operator()(Function::first_argument_type a1,
|
|
Function::second_argument_type a2,
|
|
Function::argument_3_type a3,
|
|
Function::argument_4_type a4,
|
|
Function::argument_5_type a5) const {
|
|
pmf5type pmf = reinterpret_cast<pmf5type>(pmf0);
|
|
return (objval.*pmf)(a1, a2, a3, a4, a5);
|
|
}
|
|
};
|
|
|
|
|
|
// Template Function for arity 5 obj&pmf ref storage
|
|
template<class Function, class Object> inline arity5opmf<Function>
|
|
arity5_member_obj(Object& oi, const Function &f) {
|
|
return arity5opmf<Function>(Function::object_type(oi), Function::pmf5type(f.pmf0));
|
|
};
|
|
|
|
|
|
// Template Class for arity 5 const obj&pmf ref storage
|
|
template<class Function> class arity5opmf_const:
|
|
public arity5pmf_const<const Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::result_type>,
|
|
public store_object<const Function::object_type&> {
|
|
public:
|
|
explicit inline arity5opmf_const(Function::object_type& oi, const Function &f) :
|
|
store_object<Function::object_type&>(oi), arity5pmf_const<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::result_type>(f) {}
|
|
explicit inline arity5opmf_const(Function::object_type& oi, pmf5type pmfi) :
|
|
store_object<Function::object_type&>(oi), arity5pmf_const<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::result_type>(pmfi) {}
|
|
inline arity5opmf_const(const arity5opmf_const& bndri) :
|
|
store_object<Function::object_type&>(bndri), arity5pmf_const<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::result_type>(bndri) {}
|
|
inline Function::result_type operator()(Function::first_argument_type a1,
|
|
Function::second_argument_type a2,
|
|
Function::argument_3_type a3,
|
|
Function::argument_4_type a4,
|
|
Function::argument_5_type a5) const {
|
|
pmf5type pmf = reinterpret_cast<pmf5type>(pmf0);
|
|
return (objval.*pmf)(a1, a2, a3, a4, a5);
|
|
}
|
|
};
|
|
|
|
|
|
// Template Function for arity 5 const obj&pmf ref storage
|
|
template<class Function, class Object> inline arity5opmf_const<Function>
|
|
arity5_const_member_obj(Object& oi, const Function &f) {
|
|
return arity5opmf_const<Function>(Function::object_type(oi), Function::pmf5type(f.pmf0));
|
|
};
|
|
|
|
|
|
|
|
// storage allocation classes for arity 6
|
|
|
|
// Template Class for arity 6 pmf storage
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6,
|
|
class R> class arity6pmf:
|
|
public arity6_mf<Object,
|
|
A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
R>,
|
|
public arity0pmf<Object, R> {
|
|
public:
|
|
typedef arity6_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
R>::result_type result_type;
|
|
typedef arity6_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
R>::first_argument_type first_argument_type;
|
|
typedef arity6_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
R>::second_argument_type second_argument_type;
|
|
typedef arity6_mf<Object,
|
|
A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
R>::object_type object_type;
|
|
explicit inline arity6pmf(pmf6type pmfi) :
|
|
arity0pmf<Object, R>(reinterpret_cast<pmf0type>(pmfi)) {}
|
|
inline arity6pmf(const arity6pmf& pmfi) : arity0pmf<Object, R>(pmfi) {}
|
|
inline virtual R operator()(Object& o, A1 a1,
|
|
A2 a2,
|
|
A3 a3,
|
|
A4 a4,
|
|
A5 a5,
|
|
A6 a6) const {
|
|
pmf6type pmf = reinterpret_cast<pmf6type>(pmf0);
|
|
return (o.*pmf)(a1, a2, a3, a4, a5, a6);
|
|
}
|
|
};
|
|
|
|
// Template Function for arity 6 pmf storage
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6,
|
|
class R> inline arity6pmf<Object,
|
|
A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
R>
|
|
arity6_member(R (Object::*const pmfi)(A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6)) {
|
|
return arity6pmf<Object,
|
|
A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
R>(pmfi);
|
|
};
|
|
|
|
|
|
// Template Class for arity 6 const pmf storage
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6,
|
|
class R> class arity6pmf_const:
|
|
public arity6_const_mf<const Object,
|
|
A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
R>,
|
|
public arity0pmf_const<const Object, R> {
|
|
public:
|
|
typedef arity6_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
R>::result_type result_type;
|
|
typedef arity6_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
R>::first_argument_type first_argument_type;
|
|
typedef arity6_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
R>::second_argument_type second_argument_type;
|
|
typedef arity6_const_mf<const Object,
|
|
A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
R>::object_type object_type;
|
|
explicit inline arity6pmf_const(pmf6type pmfi) :
|
|
arity0pmf_const<const Object, R>(reinterpret_cast<pmf0type>(pmfi)) {}
|
|
inline arity6pmf_const(const arity6pmf_const& pmfi) : arity0pmf_const<Object, R>(pmfi) {}
|
|
inline virtual R operator()(const Object& o, A1 a1,
|
|
A2 a2,
|
|
A3 a3,
|
|
A4 a4,
|
|
A5 a5,
|
|
A6 a6) const {
|
|
pmf6type pmf = reinterpret_cast<pmf6type>(pmf0);
|
|
return (o.*pmf)(a1, a2, a3, a4, a5, a6);
|
|
}
|
|
};
|
|
|
|
// Template Function for arity 6 const pmf storage
|
|
template<const class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6,
|
|
class R> inline arity6pmf_const<const Object,
|
|
A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
R>
|
|
arity6_const_member(R (Object::*const pmfi)(A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6) const) {
|
|
return arity6pmf_const<const Object,
|
|
A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
R>(pmfi);
|
|
};
|
|
|
|
|
|
// Template Class for arity 6 obj&pmf ref storage
|
|
template<class Function> class arity6opmf:
|
|
public arity6pmf<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type,
|
|
Function::result_type>,
|
|
public store_object<Function::object_type&> {
|
|
public:
|
|
explicit inline arity6opmf(Function::object_type& oi, const Function &f) :
|
|
store_object<Function::object_type&>(oi), arity6pmf<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type,
|
|
Function::result_type>(f) {}
|
|
explicit inline arity6opmf(Function::object_type& oi, pmf6type pmfi) :
|
|
store_object<Function::object_type&>(oi), arity6pmf<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type,
|
|
Function::result_type>(pmfi) {}
|
|
inline arity6opmf(const arity6opmf& bndri) :
|
|
store_object<Function::object_type&>(bndri), arity6pmf<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type,
|
|
Function::result_type>(bndri) {}
|
|
inline Function::result_type operator()(Function::first_argument_type a1,
|
|
Function::second_argument_type a2,
|
|
Function::argument_3_type a3,
|
|
Function::argument_4_type a4,
|
|
Function::argument_5_type a5,
|
|
Function::argument_6_type a6) const {
|
|
pmf6type pmf = reinterpret_cast<pmf6type>(pmf0);
|
|
return (objval.*pmf)(a1, a2, a3, a4, a5, a6);
|
|
}
|
|
};
|
|
|
|
|
|
// Template Function for arity 6 obj&pmf ref storage
|
|
template<class Function, class Object> inline arity6opmf<Function>
|
|
arity6_member_obj(Object& oi, const Function &f) {
|
|
return arity6opmf<Function>(Function::object_type(oi), Function::pmf6type(f.pmf0));
|
|
};
|
|
|
|
|
|
// Template Class for arity 6 const obj&pmf ref storage
|
|
template<class Function> class arity6opmf_const:
|
|
public arity6pmf_const<const Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type,
|
|
Function::result_type>,
|
|
public store_object<const Function::object_type&> {
|
|
public:
|
|
explicit inline arity6opmf_const(Function::object_type& oi, const Function &f) :
|
|
store_object<Function::object_type&>(oi), arity6pmf_const<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type,
|
|
Function::result_type>(f) {}
|
|
explicit inline arity6opmf_const(Function::object_type& oi, pmf6type pmfi) :
|
|
store_object<Function::object_type&>(oi), arity6pmf_const<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type,
|
|
Function::result_type>(pmfi) {}
|
|
inline arity6opmf_const(const arity6opmf_const& bndri) :
|
|
store_object<Function::object_type&>(bndri), arity6pmf_const<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type,
|
|
Function::result_type>(bndri) {}
|
|
inline Function::result_type operator()(Function::first_argument_type a1,
|
|
Function::second_argument_type a2,
|
|
Function::argument_3_type a3,
|
|
Function::argument_4_type a4,
|
|
Function::argument_5_type a5,
|
|
Function::argument_6_type a6) const {
|
|
pmf6type pmf = reinterpret_cast<pmf6type>(pmf0);
|
|
return (objval.*pmf)(a1, a2, a3, a4, a5, a6);
|
|
}
|
|
};
|
|
|
|
|
|
// Template Function for arity 6 const obj&pmf ref storage
|
|
template<class Function, class Object> inline arity6opmf_const<Function>
|
|
arity6_const_member_obj(Object& oi, const Function &f) {
|
|
return arity6opmf_const<Function>(Function::object_type(oi), Function::pmf6type(f.pmf0));
|
|
};
|
|
|
|
|
|
#if defined(_M_ALPHA) || (_MSC_VER < 1300)
|
|
// Template Function for arity 3 pmf storage
|
|
template<class Object,
|
|
class A1,
|
|
const class A2,
|
|
const class A3,
|
|
class R> inline arity3pmf<Object,
|
|
A1,
|
|
const A2,
|
|
const A3,
|
|
R>
|
|
arity3_member(R (Object::*const pmfi)(A1,
|
|
const A2,
|
|
const A3)) {
|
|
return arity3pmf<Object,
|
|
A1,
|
|
const A2,
|
|
const A3,
|
|
R>(pmfi);
|
|
};
|
|
#endif
|
|
|
|
#if defined(_M_ALPHA) || (_MSC_VER < 1300)
|
|
// Template Function for arity 4 const pmf storage
|
|
template<const class Object,
|
|
const class A1,
|
|
const class A2,
|
|
class A3,
|
|
const class A4,
|
|
class R> inline arity4pmf_const<const Object,
|
|
const A1,
|
|
const A2,
|
|
A3,
|
|
const A4,
|
|
R>
|
|
arity4_const_member(R (Object::*const pmfi)(const A1,
|
|
const A2,
|
|
A3,
|
|
const A4) const) {
|
|
return arity4pmf_const<const Object,
|
|
const A1,
|
|
const A2,
|
|
A3,
|
|
const A4,
|
|
R>(pmfi);
|
|
};
|
|
#endif
|
|
|
|
|
|
// storage allocation classes for arity 0
|
|
|
|
// Template Class for arity 0 function ptr storage
|
|
template<class R> class std_arity0fp:
|
|
public arity0_function<R> {
|
|
public:
|
|
typedef R ( __stdcall *const pf0type) ();
|
|
explicit inline std_arity0fp(pf0type pfi) :
|
|
pf0(pfi) {}
|
|
inline std_arity0fp(const std_arity0fp& fi) :
|
|
pf0(fi.pf0) {}
|
|
inline R operator()() const {
|
|
return pf0();
|
|
}
|
|
pf0type pf0;
|
|
};
|
|
|
|
// Template Function for arity 0 function ptr storage
|
|
template<class R> inline std_arity0fp<R>
|
|
std_arity0_pointer(R ( __stdcall *const pfi)()) {
|
|
return std_arity0fp<R>(pfi);
|
|
};
|
|
|
|
|
|
// Template Class for arity 0 pmf storage
|
|
template<class Object, class R> class std_arity0pmf:
|
|
public std_arity0_mf<Object, R> {
|
|
public:
|
|
typedef std_arity0_mf<Object, R>::object_type object_type;
|
|
explicit inline std_arity0pmf(pmf0type pmfi) :
|
|
pmf0(pmfi) {}
|
|
inline std_arity0pmf(const std_arity0pmf& pmfi) : pmf0(pmfi.pmf0) {}
|
|
inline virtual R operator()(Object& o ) const {
|
|
return (o.*pmf0)();
|
|
}
|
|
pmf0type pmf0;
|
|
};
|
|
|
|
// Template Function for arity 0 pmf storage
|
|
template<class Object, class R> inline std_arity0pmf<Object, R>
|
|
std_arity0_member(R ( __stdcall Object::*const pmfi)()) {
|
|
return std_arity0pmf<Object, R>(pmfi);
|
|
};
|
|
|
|
|
|
// Template Class for arity 0 const pmf storage
|
|
template<class Object, class R> class std_arity0pmf_const:
|
|
public std_arity0_const_mf<const Object, R> {
|
|
public:
|
|
typedef std_arity0_const_mf<const Object, R>::object_type object_type;
|
|
explicit inline std_arity0pmf_const(pmf0type pmfi) :
|
|
pmf0(pmfi) {}
|
|
inline std_arity0pmf_const(const std_arity0pmf_const& pmfi) : pmf0(pmfi.pmf0) {}
|
|
inline virtual R operator()(const Object& o ) const {
|
|
return (o.*pmf0)();
|
|
}
|
|
pmf0type pmf0;
|
|
};
|
|
|
|
// Template Function for arity 0 const pmf storage
|
|
template<const class Object, class R> inline std_arity0pmf_const<const Object, R>
|
|
std_arity0_const_member(R ( __stdcall Object::*const pmfi)() const) {
|
|
return std_arity0pmf_const<const Object, R>(pmfi);
|
|
};
|
|
|
|
template<class Object, class R> class std_arity0pmf_ptr:
|
|
public std_arity0pmf<Object, R>, public std::unary_function<Object, R> {
|
|
public:
|
|
explicit inline std_arity0pmf_ptr(pmf0type pmfi) : std_arity0pmf<Object, R>(pmfi) {}
|
|
inline std_arity0pmf_ptr(const std_arity0pmf_ptr& pmfi) : std_arity0pmf<Object, R>(pmfi) {}
|
|
inline virtual R operator()(Object& o ) const {
|
|
return (o.*pmf0)();
|
|
}
|
|
inline virtual R operator()(Object* o ) const {
|
|
return (o->*pmf0)();
|
|
}
|
|
};
|
|
|
|
// Template Function for arity 0 pmf storage
|
|
template<class Object, class R> inline std_arity0pmf_ptr<Object, R>
|
|
std_arity0_member_ptr(R (__stdcall Object::*const pmfi)()) {
|
|
return std_arity0pmf_ptr<Object, R>(pmfi);
|
|
};
|
|
|
|
// Template Class for arity 0 obj&pmf ref storage
|
|
template<class Function> class std_arity0opmf:
|
|
public std_arity0pmf<Function::object_type, Function::result_type>,
|
|
public store_object<Function::object_type&> {
|
|
public:
|
|
explicit inline std_arity0opmf(Function::object_type& oi, const Function &f) :
|
|
store_object<Function::object_type&>(oi), std_arity0pmf<Function::object_type, Function::result_type>(f) {}
|
|
explicit inline std_arity0opmf(Function::object_type& oi, pmf0type pmfi) :
|
|
store_object<Function::object_type&>(oi), std_arity0pmf<Function::object_type, Function::result_type>(pmfi) {}
|
|
inline std_arity0opmf(const std_arity0opmf& bndri) :
|
|
store_object<Function::object_type&>(bndri), std_arity0pmf<Function::object_type, Function::result_type>(bndri) {}
|
|
inline Function::result_type operator()() const {
|
|
return (objval.*pmf0)();
|
|
}
|
|
pmf0type pmf0;
|
|
};
|
|
|
|
|
|
// Template Function for arity 0 obj&pmf ref storage
|
|
template<class Function, class Object> inline std_arity0opmf<Function>
|
|
std_arity0_member_obj(Object& oi, const Function &f) {
|
|
return std_arity0opmf<Function>(Function::object_type(oi), Function::pmf0type(f.pmf0));
|
|
};
|
|
|
|
|
|
// Template Class for arity 0 const obj&pmf ref storage
|
|
template<class Function> class std_arity0opmf_const:
|
|
public std_arity0pmf_const<const Function::object_type, Function::result_type>,
|
|
public store_object<const Function::object_type&> {
|
|
public:
|
|
explicit inline std_arity0opmf_const(Function::object_type& oi, const Function &f) :
|
|
store_object<Function::object_type&>(oi), std_arity0pmf_const<Function::object_type, Function::result_type>(f) {}
|
|
explicit inline std_arity0opmf_const(Function::object_type& oi, pmf0type pmfi) :
|
|
store_object<Function::object_type&>(oi), std_arity0pmf_const<Function::object_type, Function::result_type>(pmfi) {}
|
|
inline std_arity0opmf_const(const std_arity0opmf_const& bndri) :
|
|
store_object<Function::object_type&>(bndri), std_arity0pmf_const<Function::object_type, Function::result_type>(bndri) {}
|
|
inline Function::result_type operator()() const {
|
|
return (objval.*pmf0)();
|
|
}
|
|
pmf0type pmf0;
|
|
};
|
|
|
|
|
|
// Template Function for arity 0 const obj&pmf ref storage
|
|
template<class Function, class Object> inline std_arity0opmf_const<Function>
|
|
std_arity0_const_member_obj(Object& oi, const Function &f) {
|
|
return std_arity0opmf_const<Function>(Function::object_type(oi), Function::pmf0type(f.pmf0));
|
|
};
|
|
|
|
|
|
|
|
// storage allocation classes for arity 1
|
|
|
|
// Template Class for arity 1 function ptr storage
|
|
template<class A1,
|
|
class R> class std_arity1fp:
|
|
public std::unary_function<A1,
|
|
R>,
|
|
public std_arity0fp<R> {
|
|
public:
|
|
typedef std::unary_function<A1,
|
|
R>::result_type result_type;
|
|
typedef R ( __stdcall *const pf1type) (A1);
|
|
explicit inline std_arity1fp(pf1type pfi) :
|
|
std_arity0fp<R>(reinterpret_cast<pf0type>(pfi)) {}
|
|
inline std_arity1fp(const std_arity1fp& fi) :
|
|
std_arity0fp<R>(fi) {}
|
|
inline R operator()(A1 a1) const {
|
|
pf1type pf = reinterpret_cast<pf1type>(pf0);
|
|
return pf(a1);
|
|
}
|
|
};
|
|
|
|
// Template Function for arity 1 function ptr storage
|
|
template<class A1,
|
|
class R> inline std_arity1fp<A1,
|
|
R>
|
|
std_arity1_pointer(R ( __stdcall *const pfi)(A1)) {
|
|
return std_arity1fp<A1,
|
|
R>(pfi);
|
|
};
|
|
|
|
|
|
// Template Class for arity 1 pmf storage
|
|
template<class Object,
|
|
class A1,
|
|
class R> class std_arity1pmf:
|
|
public std_arity1_mf<Object,
|
|
A1,
|
|
R>,
|
|
public std_arity0pmf<Object, R> {
|
|
public:
|
|
typedef std::unary_function<A1,
|
|
R>::result_type result_type;
|
|
typedef std_arity1_mf<Object,
|
|
A1,
|
|
R>::object_type object_type;
|
|
explicit inline std_arity1pmf(pmf1type pmfi) :
|
|
std_arity0pmf<Object, R>(reinterpret_cast<pmf0type>(pmfi)) {}
|
|
inline std_arity1pmf(const std_arity1pmf& pmfi) : std_arity0pmf<Object, R>(pmfi) {}
|
|
inline virtual R operator()(Object& o, A1 a1) const {
|
|
pmf1type pmf = reinterpret_cast<pmf1type>(pmf0);
|
|
return (o.*pmf)(a1);
|
|
}
|
|
};
|
|
|
|
// Template Function for arity 1 pmf storage
|
|
template<class Object,
|
|
class A1,
|
|
class R> inline std_arity1pmf<Object,
|
|
A1,
|
|
R>
|
|
std_arity1_member(R ( __stdcall Object::*const pmfi)(A1)) {
|
|
return std_arity1pmf<Object,
|
|
A1,
|
|
R>(pmfi);
|
|
};
|
|
|
|
|
|
// Template Class for arity 1 const pmf storage
|
|
template<class Object,
|
|
class A1,
|
|
class R> class std_arity1pmf_const:
|
|
public std_arity1_const_mf<const Object,
|
|
A1,
|
|
R>,
|
|
public std_arity0pmf_const<const Object, R> {
|
|
public:
|
|
typedef std::unary_function<A1,
|
|
R>::result_type result_type;
|
|
typedef std_arity1_const_mf<const Object,
|
|
A1,
|
|
R>::object_type object_type;
|
|
explicit inline std_arity1pmf_const(pmf1type pmfi) :
|
|
std_arity0pmf_const<const Object, R>(reinterpret_cast<pmf0type>(pmfi)) {}
|
|
inline std_arity1pmf_const(const std_arity1pmf_const& pmfi) : std_arity0pmf_const<Object, R>(pmfi) {}
|
|
inline virtual R operator()(const Object& o, A1 a1) const {
|
|
pmf1type pmf = reinterpret_cast<pmf1type>(pmf0);
|
|
return (o.*pmf)(a1);
|
|
}
|
|
};
|
|
|
|
// Template Function for arity 1 const pmf storage
|
|
template<const class Object,
|
|
class A1,
|
|
class R> inline std_arity1pmf_const<const Object,
|
|
A1,
|
|
R>
|
|
std_arity1_const_member(R ( __stdcall Object::*const pmfi)(A1) const) {
|
|
return std_arity1pmf_const<const Object,
|
|
A1,
|
|
R>(pmfi);
|
|
};
|
|
|
|
|
|
// Template Class for arity 1 obj&pmf ref storage
|
|
template<class Function> class std_arity1opmf:
|
|
public std_arity1pmf<Function::object_type,
|
|
Function::argument_type,
|
|
Function::result_type>,
|
|
public store_object<Function::object_type&> {
|
|
public:
|
|
explicit inline std_arity1opmf(Function::object_type& oi, const Function &f) :
|
|
store_object<Function::object_type&>(oi), std_arity1pmf<Function::object_type,
|
|
Function::argument_type,
|
|
Function::result_type>(f) {}
|
|
explicit inline std_arity1opmf(Function::object_type& oi, pmf1type pmfi) :
|
|
store_object<Function::object_type&>(oi), std_arity1pmf<Function::object_type,
|
|
Function::argument_type,
|
|
Function::result_type>(pmfi) {}
|
|
inline std_arity1opmf(const std_arity1opmf& bndri) :
|
|
store_object<Function::object_type&>(bndri), std_arity1pmf<Function::object_type,
|
|
Function::argument_type,
|
|
Function::result_type>(bndri) {}
|
|
inline Function::result_type operator()(Function::argument_type a1) const {
|
|
pmf1type pmf = reinterpret_cast<pmf1type>(pmf0);
|
|
return (objval.*pmf)(a1);
|
|
}
|
|
};
|
|
|
|
|
|
// Template Function for arity 1 obj&pmf ref storage
|
|
template<class Function, class Object> inline std_arity1opmf<Function>
|
|
std_arity1_member_obj(Object& oi, const Function &f) {
|
|
return std_arity1opmf<Function>(Function::object_type(oi), Function::pmf1type(f.pmf0));
|
|
};
|
|
|
|
|
|
// Template Class for arity 1 const obj&pmf ref storage
|
|
template<class Function> class std_arity1opmf_const:
|
|
public std_arity1pmf_const<const Function::object_type,
|
|
Function::argument_type,
|
|
Function::result_type>,
|
|
public store_object<const Function::object_type&> {
|
|
public:
|
|
explicit inline std_arity1opmf_const(Function::object_type& oi, const Function &f) :
|
|
store_object<Function::object_type&>(oi), std_arity1pmf_const<Function::object_type,
|
|
Function::argument_type,
|
|
Function::result_type>(f) {}
|
|
explicit inline std_arity1opmf_const(Function::object_type& oi, pmf1type pmfi) :
|
|
store_object<Function::object_type&>(oi), std_arity1pmf_const<Function::object_type,
|
|
Function::argument_type,
|
|
Function::result_type>(pmfi) {}
|
|
inline std_arity1opmf_const(const std_arity1opmf_const& bndri) :
|
|
store_object<Function::object_type&>(bndri), std_arity1pmf_const<Function::object_type,
|
|
Function::argument_type,
|
|
Function::result_type>(bndri) {}
|
|
inline Function::result_type operator()(Function::argument_type a1) const {
|
|
pmf1type pmf = reinterpret_cast<pmf1type>(pmf0);
|
|
return (objval.*pmf)(a1);
|
|
}
|
|
};
|
|
|
|
|
|
// Template Function for arity 1 const obj&pmf ref storage
|
|
template<class Function, class Object> inline std_arity1opmf_const<Function>
|
|
std_arity1_const_member_obj(Object& oi, const Function &f) {
|
|
return std_arity1opmf_const<Function>(Function::object_type(oi), Function::pmf1type(f.pmf0));
|
|
};
|
|
|
|
|
|
|
|
// storage allocation classes for arity 2
|
|
|
|
// Template Class for arity 2 function ptr storage
|
|
template<class A1,
|
|
class A2,
|
|
class R> class std_arity2fp:
|
|
public std::binary_function<A1,
|
|
A2,
|
|
R>,
|
|
public std_arity0fp<R> {
|
|
public:
|
|
typedef std::binary_function<A1,
|
|
A2,
|
|
R>::result_type result_type;
|
|
typedef std::binary_function<A1,
|
|
A2,
|
|
R>::first_argument_type first_argument_type;
|
|
typedef R ( __stdcall *const pf2type) (A1, A2);
|
|
explicit inline std_arity2fp(pf2type pfi) :
|
|
std_arity0fp<R>(reinterpret_cast<pf0type>(pfi)) {}
|
|
inline std_arity2fp(const std_arity2fp& fi) :
|
|
std_arity0fp<R>(fi) {}
|
|
inline R operator()(A1 a1,
|
|
A2 a2) const {
|
|
pf2type pf = reinterpret_cast<pf2type>(pf0);
|
|
return pf(a1, a2);
|
|
}
|
|
};
|
|
|
|
// Template Function for arity 2 function ptr storage
|
|
template<class A1,
|
|
class A2,
|
|
class R> inline std_arity2fp<A1,
|
|
A2,
|
|
R>
|
|
std_arity2_pointer(R ( __stdcall *const pfi)(A1,
|
|
A2)) {
|
|
return std_arity2fp<A1,
|
|
A2,
|
|
R>(pfi);
|
|
};
|
|
|
|
|
|
// Template Class for arity 2 pmf storage
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class R> class std_arity2pmf:
|
|
public std_arity2_mf<Object,
|
|
A1,
|
|
A2,
|
|
R>,
|
|
public std_arity0pmf<Object, R> {
|
|
public:
|
|
typedef std::binary_function<A1,
|
|
A2,
|
|
R>::result_type result_type;
|
|
typedef std::binary_function<A1,
|
|
A2,
|
|
R>::first_argument_type first_argument_type;
|
|
typedef std_arity2_mf<Object,
|
|
A1,
|
|
A2,
|
|
R>::object_type object_type;
|
|
explicit inline std_arity2pmf(pmf2type pmfi) :
|
|
std_arity0pmf<Object, R>(reinterpret_cast<pmf0type>(pmfi)) {}
|
|
inline std_arity2pmf(const std_arity2pmf& pmfi) : std_arity0pmf<Object, R>(pmfi) {}
|
|
inline virtual R operator()(Object& o, A1 a1,
|
|
A2 a2) const {
|
|
pmf2type pmf = reinterpret_cast<pmf2type>(pmf0);
|
|
return (o.*pmf)(a1, a2);
|
|
}
|
|
};
|
|
|
|
// Template Function for arity 2 pmf storage
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class R> inline std_arity2pmf<Object,
|
|
A1,
|
|
A2,
|
|
R>
|
|
std_arity2_member(R ( __stdcall Object::*const pmfi)(A1,
|
|
A2)) {
|
|
return std_arity2pmf<Object,
|
|
A1,
|
|
A2,
|
|
R>(pmfi);
|
|
};
|
|
|
|
|
|
// Template Class for arity 2 const pmf storage
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class R> class std_arity2pmf_const:
|
|
public std_arity2_const_mf<const Object,
|
|
A1,
|
|
A2,
|
|
R>,
|
|
public std_arity0pmf_const<const Object, R> {
|
|
public:
|
|
typedef std::binary_function<A1,
|
|
A2,
|
|
R>::result_type result_type;
|
|
typedef std::binary_function<A1,
|
|
A2,
|
|
R>::first_argument_type first_argument_type;
|
|
typedef std_arity2_const_mf<const Object,
|
|
A1,
|
|
A2,
|
|
R>::object_type object_type;
|
|
explicit inline std_arity2pmf_const(pmf2type pmfi) :
|
|
std_arity0pmf_const<const Object, R>(reinterpret_cast<pmf0type>(pmfi)) {}
|
|
inline std_arity2pmf_const(const std_arity2pmf_const& pmfi) : std_arity0pmf_const<Object, R>(pmfi) {}
|
|
inline virtual R operator()(const Object& o, A1 a1,
|
|
A2 a2) const {
|
|
pmf2type pmf = reinterpret_cast<pmf2type>(pmf0);
|
|
return (o.*pmf)(a1, a2);
|
|
}
|
|
};
|
|
|
|
// Template Function for arity 2 const pmf storage
|
|
template<const class Object,
|
|
class A1,
|
|
class A2,
|
|
class R> inline std_arity2pmf_const<const Object,
|
|
A1,
|
|
A2,
|
|
R>
|
|
std_arity2_const_member(R ( __stdcall Object::*const pmfi)(A1,
|
|
A2) const) {
|
|
return std_arity2pmf_const<const Object,
|
|
A1,
|
|
A2,
|
|
R>(pmfi);
|
|
};
|
|
|
|
|
|
// Template Class for arity 2 obj&pmf ref storage
|
|
template<class Function> class std_arity2opmf:
|
|
public std_arity2pmf<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::result_type>,
|
|
public store_object<Function::object_type&> {
|
|
public:
|
|
explicit inline std_arity2opmf(Function::object_type& oi, const Function &f) :
|
|
store_object<Function::object_type&>(oi), std_arity2pmf<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::result_type>(f) {}
|
|
explicit inline std_arity2opmf(Function::object_type& oi, pmf2type pmfi) :
|
|
store_object<Function::object_type&>(oi), std_arity2pmf<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::result_type>(pmfi) {}
|
|
inline std_arity2opmf(const std_arity2opmf& bndri) :
|
|
store_object<Function::object_type&>(bndri), std_arity2pmf<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::result_type>(bndri) {}
|
|
inline Function::result_type operator()(Function::first_argument_type a1,
|
|
Function::second_argument_type a2) const {
|
|
pmf2type pmf = reinterpret_cast<pmf2type>(pmf0);
|
|
return (objval.*pmf)(a1, a2);
|
|
}
|
|
};
|
|
|
|
|
|
// Template Function for arity 2 obj&pmf ref storage
|
|
template<class Function, class Object> inline std_arity2opmf<Function>
|
|
std_arity2_member_obj(Object& oi, const Function &f) {
|
|
return std_arity2opmf<Function>(Function::object_type(oi), Function::pmf2type(f.pmf0));
|
|
};
|
|
|
|
|
|
// Template Class for arity 2 const obj&pmf ref storage
|
|
template<class Function> class std_arity2opmf_const:
|
|
public std_arity2pmf_const<const Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::result_type>,
|
|
public store_object<const Function::object_type&> {
|
|
public:
|
|
explicit inline std_arity2opmf_const(Function::object_type& oi, const Function &f) :
|
|
store_object<Function::object_type&>(oi), std_arity2pmf_const<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::result_type>(f) {}
|
|
explicit inline std_arity2opmf_const(Function::object_type& oi, pmf2type pmfi) :
|
|
store_object<Function::object_type&>(oi), std_arity2pmf_const<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::result_type>(pmfi) {}
|
|
inline std_arity2opmf_const(const std_arity2opmf_const& bndri) :
|
|
store_object<Function::object_type&>(bndri), std_arity2pmf_const<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::result_type>(bndri) {}
|
|
inline Function::result_type operator()(Function::first_argument_type a1,
|
|
Function::second_argument_type a2) const {
|
|
pmf2type pmf = reinterpret_cast<pmf2type>(pmf0);
|
|
return (objval.*pmf)(a1, a2);
|
|
}
|
|
};
|
|
|
|
|
|
// Template Function for arity 2 const obj&pmf ref storage
|
|
template<class Function, class Object> inline std_arity2opmf_const<Function>
|
|
std_arity2_const_member_obj(Object& oi, const Function &f) {
|
|
return std_arity2opmf_const<Function>(Function::object_type(oi), Function::pmf2type(f.pmf0));
|
|
};
|
|
|
|
|
|
|
|
// storage allocation classes for arity 3
|
|
|
|
// Template Class for arity 3 function ptr storage
|
|
template<class A1,
|
|
class A2,
|
|
class A3,
|
|
class R> class std_arity3fp:
|
|
public arity3_function<A1,
|
|
A2,
|
|
A3,
|
|
R>,
|
|
public std_arity0fp<R> {
|
|
public:
|
|
typedef arity3_function<A1,
|
|
A2,
|
|
A3,
|
|
R>::result_type result_type;
|
|
typedef arity3_function<A1,
|
|
A2,
|
|
A3,
|
|
R>::first_argument_type first_argument_type;
|
|
typedef arity3_function<A1,
|
|
A2,
|
|
A3,
|
|
R>::second_argument_type second_argument_type;
|
|
typedef R ( __stdcall *const pf3type) (A1, A2, A3);
|
|
explicit inline std_arity3fp(pf3type pfi) :
|
|
std_arity0fp<R>(reinterpret_cast<pf0type>(pfi)) {}
|
|
inline std_arity3fp(const std_arity3fp& fi) :
|
|
std_arity0fp<R>(fi) {}
|
|
inline R operator()(A1 a1,
|
|
A2 a2,
|
|
A3 a3) const {
|
|
pf3type pf = reinterpret_cast<pf3type>(pf0);
|
|
return pf(a1, a2, a3);
|
|
}
|
|
};
|
|
|
|
// Template Function for arity 3 function ptr storage
|
|
template<class A1,
|
|
class A2,
|
|
class A3,
|
|
class R> inline std_arity3fp<A1,
|
|
A2,
|
|
A3,
|
|
R>
|
|
std_arity3_pointer(R ( __stdcall *const pfi)(A1,
|
|
A2,
|
|
A3)) {
|
|
return std_arity3fp<A1,
|
|
A2,
|
|
A3,
|
|
R>(pfi);
|
|
};
|
|
|
|
|
|
// Template Class for arity 3 pmf storage
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class R> class std_arity3pmf:
|
|
public std_arity3_mf<Object,
|
|
A1,
|
|
A2,
|
|
A3,
|
|
R>,
|
|
public std_arity0pmf<Object, R> {
|
|
public:
|
|
typedef arity3_function<A1,
|
|
A2,
|
|
A3,
|
|
R>::result_type result_type;
|
|
typedef arity3_function<A1,
|
|
A2,
|
|
A3,
|
|
R>::first_argument_type first_argument_type;
|
|
typedef arity3_function<A1,
|
|
A2,
|
|
A3,
|
|
R>::second_argument_type second_argument_type;
|
|
typedef std_arity3_mf<Object,
|
|
A1,
|
|
A2,
|
|
A3,
|
|
R>::object_type object_type;
|
|
explicit inline std_arity3pmf(pmf3type pmfi) :
|
|
std_arity0pmf<Object, R>(reinterpret_cast<pmf0type>(pmfi)) {}
|
|
inline std_arity3pmf(const std_arity3pmf& pmfi) : std_arity0pmf<Object, R>(pmfi) {}
|
|
inline virtual R operator()(Object& o, A1 a1,
|
|
A2 a2,
|
|
A3 a3) const {
|
|
pmf3type pmf = reinterpret_cast<pmf3type>(pmf0);
|
|
return (o.*pmf)(a1, a2, a3);
|
|
}
|
|
};
|
|
|
|
// Template Function for arity 3 pmf storage
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class R> inline std_arity3pmf<Object,
|
|
A1,
|
|
A2,
|
|
A3,
|
|
R>
|
|
std_arity3_member(R ( __stdcall Object::*const pmfi)(A1,
|
|
A2,
|
|
A3)) {
|
|
return std_arity3pmf<Object,
|
|
A1,
|
|
A2,
|
|
A3,
|
|
R>(pmfi);
|
|
};
|
|
|
|
|
|
// Template Class for arity 3 const pmf storage
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class R> class std_arity3pmf_const:
|
|
public std_arity3_const_mf<const Object,
|
|
A1,
|
|
A2,
|
|
A3,
|
|
R>,
|
|
public std_arity0pmf_const<const Object, R> {
|
|
public:
|
|
typedef arity3_function<A1,
|
|
A2,
|
|
A3,
|
|
R>::result_type result_type;
|
|
typedef arity3_function<A1,
|
|
A2,
|
|
A3,
|
|
R>::first_argument_type first_argument_type;
|
|
typedef arity3_function<A1,
|
|
A2,
|
|
A3,
|
|
R>::second_argument_type second_argument_type;
|
|
typedef std_arity3_const_mf<const Object,
|
|
A1,
|
|
A2,
|
|
A3,
|
|
R>::object_type object_type;
|
|
explicit inline std_arity3pmf_const(pmf3type pmfi) :
|
|
std_arity0pmf_const<const Object, R>(reinterpret_cast<pmf0type>(pmfi)) {}
|
|
inline std_arity3pmf_const(const std_arity3pmf_const& pmfi) : std_arity0pmf_const<Object, R>(pmfi) {}
|
|
inline virtual R operator()(const Object& o, A1 a1,
|
|
A2 a2,
|
|
A3 a3) const {
|
|
pmf3type pmf = reinterpret_cast<pmf3type>(pmf0);
|
|
return (o.*pmf)(a1, a2, a3);
|
|
}
|
|
};
|
|
|
|
// Template Function for arity 3 const pmf storage
|
|
template<const class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class R> inline std_arity3pmf_const<const Object,
|
|
A1,
|
|
A2,
|
|
A3,
|
|
R>
|
|
std_arity3_const_member(R ( __stdcall Object::*const pmfi)(A1,
|
|
A2,
|
|
A3) const) {
|
|
return std_arity3pmf_const<const Object,
|
|
A1,
|
|
A2,
|
|
A3,
|
|
R>(pmfi);
|
|
};
|
|
|
|
|
|
// Template Class for arity 3 obj&pmf ref storage
|
|
template<class Function> class std_arity3opmf:
|
|
public std_arity3pmf<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::result_type>,
|
|
public store_object<Function::object_type&> {
|
|
public:
|
|
explicit inline std_arity3opmf(Function::object_type& oi, const Function &f) :
|
|
store_object<Function::object_type&>(oi), std_arity3pmf<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::result_type>(f) {}
|
|
explicit inline std_arity3opmf(Function::object_type& oi, pmf3type pmfi) :
|
|
store_object<Function::object_type&>(oi), std_arity3pmf<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::result_type>(pmfi) {}
|
|
inline std_arity3opmf(const std_arity3opmf& bndri) :
|
|
store_object<Function::object_type&>(bndri), std_arity3pmf<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::result_type>(bndri) {}
|
|
inline Function::result_type operator()(Function::first_argument_type a1,
|
|
Function::second_argument_type a2,
|
|
Function::argument_3_type a3) const {
|
|
pmf3type pmf = reinterpret_cast<pmf3type>(pmf0);
|
|
return (objval.*pmf)(a1, a2, a3);
|
|
}
|
|
};
|
|
|
|
|
|
// Template Function for arity 3 obj&pmf ref storage
|
|
template<class Function, class Object> inline std_arity3opmf<Function>
|
|
std_arity3_member_obj(Object& oi, const Function &f) {
|
|
return std_arity3opmf<Function>(Function::object_type(oi), Function::pmf3type(f.pmf0));
|
|
};
|
|
|
|
|
|
// Template Class for arity 3 const obj&pmf ref storage
|
|
template<class Function> class std_arity3opmf_const:
|
|
public std_arity3pmf_const<const Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::result_type>,
|
|
public store_object<const Function::object_type&> {
|
|
public:
|
|
explicit inline std_arity3opmf_const(Function::object_type& oi, const Function &f) :
|
|
store_object<Function::object_type&>(oi), std_arity3pmf_const<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::result_type>(f) {}
|
|
explicit inline std_arity3opmf_const(Function::object_type& oi, pmf3type pmfi) :
|
|
store_object<Function::object_type&>(oi), std_arity3pmf_const<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::result_type>(pmfi) {}
|
|
inline std_arity3opmf_const(const std_arity3opmf_const& bndri) :
|
|
store_object<Function::object_type&>(bndri), std_arity3pmf_const<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::result_type>(bndri) {}
|
|
inline Function::result_type operator()(Function::first_argument_type a1,
|
|
Function::second_argument_type a2,
|
|
Function::argument_3_type a3) const {
|
|
pmf3type pmf = reinterpret_cast<pmf3type>(pmf0);
|
|
return (objval.*pmf)(a1, a2, a3);
|
|
}
|
|
};
|
|
|
|
|
|
// Template Function for arity 3 const obj&pmf ref storage
|
|
template<class Function, class Object> inline std_arity3opmf_const<Function>
|
|
std_arity3_const_member_obj(Object& oi, const Function &f) {
|
|
return std_arity3opmf_const<Function>(Function::object_type(oi), Function::pmf3type(f.pmf0));
|
|
};
|
|
|
|
|
|
|
|
// storage allocation classes for arity 4
|
|
|
|
// Template Class for arity 4 pmf storage
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class R> class std_arity4pmf:
|
|
public std_arity4_mf<Object,
|
|
A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
R>,
|
|
public std_arity0pmf<Object, R> {
|
|
public:
|
|
typedef arity4_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
R>::result_type result_type;
|
|
typedef arity4_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
R>::first_argument_type first_argument_type;
|
|
typedef arity4_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
R>::second_argument_type second_argument_type;
|
|
typedef std_arity4_mf<Object,
|
|
A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
R>::object_type object_type;
|
|
explicit inline std_arity4pmf(pmf4type pmfi) :
|
|
std_arity0pmf<Object, R>(reinterpret_cast<pmf0type>(pmfi)) {}
|
|
inline std_arity4pmf(const std_arity4pmf& pmfi) : std_arity0pmf<Object, R>(pmfi) {}
|
|
inline virtual R operator()(Object& o, A1 a1,
|
|
A2 a2,
|
|
A3 a3,
|
|
A4 a4) const {
|
|
pmf4type pmf = reinterpret_cast<pmf4type>(pmf0);
|
|
return (o.*pmf)(a1, a2, a3, a4);
|
|
}
|
|
};
|
|
|
|
// Template Function for arity 4 pmf storage
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class R> inline std_arity4pmf<Object,
|
|
A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
R>
|
|
std_arity4_member(R ( __stdcall Object::*const pmfi)(A1,
|
|
A2,
|
|
A3,
|
|
A4)) {
|
|
return std_arity4pmf<Object,
|
|
A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
R>(pmfi);
|
|
};
|
|
|
|
|
|
// Template Class for arity 4 const pmf storage
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class R> class std_arity4pmf_const:
|
|
public std_arity4_const_mf<const Object,
|
|
A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
R>,
|
|
public std_arity0pmf_const<const Object, R> {
|
|
public:
|
|
typedef arity4_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
R>::result_type result_type;
|
|
typedef arity4_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
R>::first_argument_type first_argument_type;
|
|
typedef arity4_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
R>::second_argument_type second_argument_type;
|
|
typedef std_arity4_const_mf<const Object,
|
|
A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
R>::object_type object_type;
|
|
explicit inline std_arity4pmf_const(pmf4type pmfi) :
|
|
std_arity0pmf_const<const Object, R>(reinterpret_cast<pmf0type>(pmfi)) {}
|
|
inline std_arity4pmf_const(const std_arity4pmf_const& pmfi) : std_arity0pmf_const<Object, R>(pmfi) {}
|
|
inline virtual R operator()(const Object& o, A1 a1,
|
|
A2 a2,
|
|
A3 a3,
|
|
A4 a4) const {
|
|
pmf4type pmf = reinterpret_cast<pmf4type>(pmf0);
|
|
return (o.*pmf)(a1, a2, a3, a4);
|
|
}
|
|
};
|
|
|
|
// Template Function for arity 4 const pmf storage
|
|
template<const class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class R> inline std_arity4pmf_const<const Object,
|
|
A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
R>
|
|
std_arity4_const_member(R ( __stdcall Object::*const pmfi)(A1,
|
|
A2,
|
|
A3,
|
|
A4) const) {
|
|
return std_arity4pmf_const<const Object,
|
|
A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
R>(pmfi);
|
|
};
|
|
|
|
|
|
// Template Class for arity 4 obj&pmf ref storage
|
|
template<class Function> class std_arity4opmf:
|
|
public std_arity4pmf<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::result_type>,
|
|
public store_object<Function::object_type&> {
|
|
public:
|
|
explicit inline std_arity4opmf(Function::object_type& oi, const Function &f) :
|
|
store_object<Function::object_type&>(oi), std_arity4pmf<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::result_type>(f) {}
|
|
explicit inline std_arity4opmf(Function::object_type& oi, pmf4type pmfi) :
|
|
store_object<Function::object_type&>(oi), std_arity4pmf<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::result_type>(pmfi) {}
|
|
inline std_arity4opmf(const std_arity4opmf& bndri) :
|
|
store_object<Function::object_type&>(bndri), std_arity4pmf<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::result_type>(bndri) {}
|
|
inline Function::result_type operator()(Function::first_argument_type a1,
|
|
Function::second_argument_type a2,
|
|
Function::argument_3_type a3,
|
|
Function::argument_4_type a4) const {
|
|
pmf4type pmf = reinterpret_cast<pmf4type>(pmf0);
|
|
return (objval.*pmf)(a1, a2, a3, a4);
|
|
}
|
|
};
|
|
|
|
|
|
// Template Function for arity 4 obj&pmf ref storage
|
|
template<class Function, class Object> inline std_arity4opmf<Function>
|
|
std_arity4_member_obj(Object& oi, const Function &f) {
|
|
return std_arity4opmf<Function>(Function::object_type(oi), Function::pmf4type(f.pmf0));
|
|
};
|
|
|
|
|
|
// Template Class for arity 4 const obj&pmf ref storage
|
|
template<class Function> class std_arity4opmf_const:
|
|
public std_arity4pmf_const<const Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::result_type>,
|
|
public store_object<const Function::object_type&> {
|
|
public:
|
|
explicit inline std_arity4opmf_const(Function::object_type& oi, const Function &f) :
|
|
store_object<Function::object_type&>(oi), std_arity4pmf_const<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::result_type>(f) {}
|
|
explicit inline std_arity4opmf_const(Function::object_type& oi, pmf4type pmfi) :
|
|
store_object<Function::object_type&>(oi), std_arity4pmf_const<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::result_type>(pmfi) {}
|
|
inline std_arity4opmf_const(const std_arity4opmf_const& bndri) :
|
|
store_object<Function::object_type&>(bndri), std_arity4pmf_const<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::result_type>(bndri) {}
|
|
inline Function::result_type operator()(Function::first_argument_type a1,
|
|
Function::second_argument_type a2,
|
|
Function::argument_3_type a3,
|
|
Function::argument_4_type a4) const {
|
|
pmf4type pmf = reinterpret_cast<pmf4type>(pmf0);
|
|
return (objval.*pmf)(a1, a2, a3, a4);
|
|
}
|
|
};
|
|
|
|
|
|
// Template Function for arity 4 const obj&pmf ref storage
|
|
template<class Function, class Object> inline std_arity4opmf_const<Function>
|
|
std_arity4_const_member_obj(Object& oi, const Function &f) {
|
|
return std_arity4opmf_const<Function>(Function::object_type(oi), Function::pmf4type(f.pmf0));
|
|
};
|
|
|
|
|
|
|
|
// storage allocation classes for arity 5
|
|
|
|
// Template Class for arity 5 pmf storage
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class R> class std_arity5pmf:
|
|
public std_arity5_mf<Object,
|
|
A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
R>,
|
|
public std_arity0pmf<Object, R> {
|
|
public:
|
|
typedef arity5_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
R>::result_type result_type;
|
|
typedef arity5_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
R>::first_argument_type first_argument_type;
|
|
typedef arity5_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
R>::second_argument_type second_argument_type;
|
|
typedef std_arity5_mf<Object,
|
|
A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
R>::object_type object_type;
|
|
explicit inline std_arity5pmf(pmf5type pmfi) :
|
|
std_arity0pmf<Object, R>(reinterpret_cast<pmf0type>(pmfi)) {}
|
|
inline std_arity5pmf(const std_arity5pmf& pmfi) : std_arity0pmf<Object, R>(pmfi) {}
|
|
inline virtual R operator()(Object& o, A1 a1,
|
|
A2 a2,
|
|
A3 a3,
|
|
A4 a4,
|
|
A5 a5) const {
|
|
pmf5type pmf = reinterpret_cast<pmf5type>(pmf0);
|
|
return (o.*pmf)(a1, a2, a3, a4, a5);
|
|
}
|
|
};
|
|
|
|
// Template Function for arity 5 pmf storage
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class R> inline std_arity5pmf<Object,
|
|
A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
R>
|
|
std_arity5_member(R ( __stdcall Object::*const pmfi)(A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5)) {
|
|
return std_arity5pmf<Object,
|
|
A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
R>(pmfi);
|
|
};
|
|
|
|
|
|
// Template Class for arity 5 const pmf storage
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class R> class std_arity5pmf_const:
|
|
public std_arity5_const_mf<const Object,
|
|
A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
R>,
|
|
public std_arity0pmf_const<const Object, R> {
|
|
public:
|
|
typedef arity5_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
R>::result_type result_type;
|
|
typedef arity5_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
R>::first_argument_type first_argument_type;
|
|
typedef arity5_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
R>::second_argument_type second_argument_type;
|
|
typedef std_arity5_const_mf<const Object,
|
|
A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
R>::object_type object_type;
|
|
explicit inline std_arity5pmf_const(pmf5type pmfi) :
|
|
std_arity0pmf_const<const Object, R>(reinterpret_cast<pmf0type>(pmfi)) {}
|
|
inline std_arity5pmf_const(const std_arity5pmf_const& pmfi) : std_arity0pmf_const<Object, R>(pmfi) {}
|
|
inline virtual R operator()(const Object& o, A1 a1,
|
|
A2 a2,
|
|
A3 a3,
|
|
A4 a4,
|
|
A5 a5) const {
|
|
pmf5type pmf = reinterpret_cast<pmf5type>(pmf0);
|
|
return (o.*pmf)(a1, a2, a3, a4, a5);
|
|
}
|
|
};
|
|
|
|
// Template Function for arity 5 const pmf storage
|
|
template<const class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class R> inline std_arity5pmf_const<const Object,
|
|
A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
R>
|
|
std_arity5_const_member(R ( __stdcall Object::*const pmfi)(A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5) const) {
|
|
return std_arity5pmf_const<const Object,
|
|
A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
R>(pmfi);
|
|
};
|
|
|
|
|
|
// Template Class for arity 5 obj&pmf ref storage
|
|
template<class Function> class std_arity5opmf:
|
|
public std_arity5pmf<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::result_type>,
|
|
public store_object<Function::object_type&> {
|
|
public:
|
|
explicit inline std_arity5opmf(Function::object_type& oi, const Function &f) :
|
|
store_object<Function::object_type&>(oi), std_arity5pmf<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::result_type>(f) {}
|
|
explicit inline std_arity5opmf(Function::object_type& oi, pmf5type pmfi) :
|
|
store_object<Function::object_type&>(oi), std_arity5pmf<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::result_type>(pmfi) {}
|
|
inline std_arity5opmf(const std_arity5opmf& bndri) :
|
|
store_object<Function::object_type&>(bndri), std_arity5pmf<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::result_type>(bndri) {}
|
|
inline Function::result_type operator()(Function::first_argument_type a1,
|
|
Function::second_argument_type a2,
|
|
Function::argument_3_type a3,
|
|
Function::argument_4_type a4,
|
|
Function::argument_5_type a5) const {
|
|
pmf5type pmf = reinterpret_cast<pmf5type>(pmf0);
|
|
return (objval.*pmf)(a1, a2, a3, a4, a5);
|
|
}
|
|
};
|
|
|
|
|
|
// Template Function for arity 5 obj&pmf ref storage
|
|
template<class Function, class Object> inline std_arity5opmf<Function>
|
|
std_arity5_member_obj(Object& oi, const Function &f) {
|
|
return std_arity5opmf<Function>(Function::object_type(oi), Function::pmf5type(f.pmf0));
|
|
};
|
|
|
|
|
|
// Template Class for arity 5 const obj&pmf ref storage
|
|
template<class Function> class std_arity5opmf_const:
|
|
public std_arity5pmf_const<const Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::result_type>,
|
|
public store_object<const Function::object_type&> {
|
|
public:
|
|
explicit inline std_arity5opmf_const(Function::object_type& oi, const Function &f) :
|
|
store_object<Function::object_type&>(oi), std_arity5pmf_const<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::result_type>(f) {}
|
|
explicit inline std_arity5opmf_const(Function::object_type& oi, pmf5type pmfi) :
|
|
store_object<Function::object_type&>(oi), std_arity5pmf_const<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::result_type>(pmfi) {}
|
|
inline std_arity5opmf_const(const std_arity5opmf_const& bndri) :
|
|
store_object<Function::object_type&>(bndri), std_arity5pmf_const<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::result_type>(bndri) {}
|
|
inline Function::result_type operator()(Function::first_argument_type a1,
|
|
Function::second_argument_type a2,
|
|
Function::argument_3_type a3,
|
|
Function::argument_4_type a4,
|
|
Function::argument_5_type a5) const {
|
|
pmf5type pmf = reinterpret_cast<pmf5type>(pmf0);
|
|
return (objval.*pmf)(a1, a2, a3, a4, a5);
|
|
}
|
|
};
|
|
|
|
|
|
// Template Function for arity 5 const obj&pmf ref storage
|
|
template<class Function, class Object> inline std_arity5opmf_const<Function>
|
|
std_arity5_const_member_obj(Object& oi, const Function &f) {
|
|
return std_arity5opmf_const<Function>(Function::object_type(oi), Function::pmf5type(f.pmf0));
|
|
};
|
|
|
|
|
|
|
|
// storage allocation classes for arity 6
|
|
|
|
// Template Class for arity 6 pmf storage
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6,
|
|
class R> class std_arity6pmf:
|
|
public std_arity6_mf<Object,
|
|
A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
R>,
|
|
public std_arity0pmf<Object, R> {
|
|
public:
|
|
typedef arity6_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
R>::result_type result_type;
|
|
typedef arity6_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
R>::first_argument_type first_argument_type;
|
|
typedef arity6_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
R>::second_argument_type second_argument_type;
|
|
typedef std_arity6_mf<Object,
|
|
A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
R>::object_type object_type;
|
|
explicit inline std_arity6pmf(pmf6type pmfi) :
|
|
std_arity0pmf<Object, R>(reinterpret_cast<pmf0type>(pmfi)) {}
|
|
inline std_arity6pmf(const std_arity6pmf& pmfi) : std_arity0pmf<Object, R>(pmfi) {}
|
|
inline virtual R operator()(Object& o, A1 a1,
|
|
A2 a2,
|
|
A3 a3,
|
|
A4 a4,
|
|
A5 a5,
|
|
A6 a6) const {
|
|
pmf6type pmf = reinterpret_cast<pmf6type>(pmf0);
|
|
return (o.*pmf)(a1, a2, a3, a4, a5, a6);
|
|
}
|
|
};
|
|
|
|
// Template Function for arity 6 pmf storage
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6,
|
|
class R> inline std_arity6pmf<Object,
|
|
A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
R>
|
|
std_arity6_member(R ( __stdcall Object::*const pmfi)(A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6)) {
|
|
return std_arity6pmf<Object,
|
|
A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
R>(pmfi);
|
|
};
|
|
|
|
|
|
// Template Class for arity 6 const pmf storage
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6,
|
|
class R> class std_arity6pmf_const:
|
|
public std_arity6_const_mf<const Object,
|
|
A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
R>,
|
|
public std_arity0pmf_const<const Object, R> {
|
|
public:
|
|
typedef arity6_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
R>::result_type result_type;
|
|
typedef arity6_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
R>::first_argument_type first_argument_type;
|
|
typedef arity6_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
R>::second_argument_type second_argument_type;
|
|
typedef std_arity6_const_mf<const Object,
|
|
A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
R>::object_type object_type;
|
|
explicit inline std_arity6pmf_const(pmf6type pmfi) :
|
|
std_arity0pmf_const<const Object, R>(reinterpret_cast<pmf0type>(pmfi)) {}
|
|
inline std_arity6pmf_const(const std_arity6pmf_const& pmfi) : std_arity0pmf_const<Object, R>(pmfi) {}
|
|
inline virtual R operator()(const Object& o, A1 a1,
|
|
A2 a2,
|
|
A3 a3,
|
|
A4 a4,
|
|
A5 a5,
|
|
A6 a6) const {
|
|
pmf6type pmf = reinterpret_cast<pmf6type>(pmf0);
|
|
return (o.*pmf)(a1, a2, a3, a4, a5, a6);
|
|
}
|
|
};
|
|
|
|
// Template Function for arity 6 const pmf storage
|
|
template<const class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6,
|
|
class R> inline std_arity6pmf_const<const Object,
|
|
A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
R>
|
|
std_arity6_const_member(R ( __stdcall Object::*const pmfi)(A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6) const) {
|
|
return std_arity6pmf_const<const Object,
|
|
A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
R>(pmfi);
|
|
};
|
|
|
|
|
|
// Template Class for arity 6 obj&pmf ref storage
|
|
template<class Function> class std_arity6opmf:
|
|
public std_arity6pmf<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type,
|
|
Function::result_type>,
|
|
public store_object<Function::object_type&> {
|
|
public:
|
|
explicit inline std_arity6opmf(Function::object_type& oi, const Function &f) :
|
|
store_object<Function::object_type&>(oi), std_arity6pmf<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type,
|
|
Function::result_type>(f) {}
|
|
explicit inline std_arity6opmf(Function::object_type& oi, pmf6type pmfi) :
|
|
store_object<Function::object_type&>(oi), std_arity6pmf<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type,
|
|
Function::result_type>(pmfi) {}
|
|
inline std_arity6opmf(const std_arity6opmf& bndri) :
|
|
store_object<Function::object_type&>(bndri), std_arity6pmf<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type,
|
|
Function::result_type>(bndri) {}
|
|
inline Function::result_type operator()(Function::first_argument_type a1,
|
|
Function::second_argument_type a2,
|
|
Function::argument_3_type a3,
|
|
Function::argument_4_type a4,
|
|
Function::argument_5_type a5,
|
|
Function::argument_6_type a6) const {
|
|
pmf6type pmf = reinterpret_cast<pmf6type>(pmf0);
|
|
return (objval.*pmf)(a1, a2, a3, a4, a5, a6);
|
|
}
|
|
};
|
|
|
|
|
|
// Template Function for arity 6 obj&pmf ref storage
|
|
template<class Function, class Object> inline std_arity6opmf<Function>
|
|
std_arity6_member_obj(Object& oi, const Function &f) {
|
|
return std_arity6opmf<Function>(Function::object_type(oi), Function::pmf6type(f.pmf0));
|
|
};
|
|
|
|
|
|
// Template Class for arity 6 const obj&pmf ref storage
|
|
template<class Function> class std_arity6opmf_const:
|
|
public std_arity6pmf_const<const Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type,
|
|
Function::result_type>,
|
|
public store_object<const Function::object_type&> {
|
|
public:
|
|
explicit inline std_arity6opmf_const(Function::object_type& oi, const Function &f) :
|
|
store_object<Function::object_type&>(oi), std_arity6pmf_const<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type,
|
|
Function::result_type>(f) {}
|
|
explicit inline std_arity6opmf_const(Function::object_type& oi, pmf6type pmfi) :
|
|
store_object<Function::object_type&>(oi), std_arity6pmf_const<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type,
|
|
Function::result_type>(pmfi) {}
|
|
inline std_arity6opmf_const(const std_arity6opmf_const& bndri) :
|
|
store_object<Function::object_type&>(bndri), std_arity6pmf_const<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type,
|
|
Function::result_type>(bndri) {}
|
|
inline Function::result_type operator()(Function::first_argument_type a1,
|
|
Function::second_argument_type a2,
|
|
Function::argument_3_type a3,
|
|
Function::argument_4_type a4,
|
|
Function::argument_5_type a5,
|
|
Function::argument_6_type a6) const {
|
|
pmf6type pmf = reinterpret_cast<pmf6type>(pmf0);
|
|
return (objval.*pmf)(a1, a2, a3, a4, a5, a6);
|
|
}
|
|
};
|
|
|
|
|
|
// Template Function for arity 6 const obj&pmf ref storage
|
|
template<class Function, class Object> inline std_arity6opmf_const<Function>
|
|
std_arity6_const_member_obj(Object& oi, const Function &f) {
|
|
return std_arity6opmf_const<Function>(Function::object_type(oi), Function::pmf6type(f.pmf0));
|
|
};
|
|
|
|
|
|
// Template Class for arity 15 pmf storage
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6,
|
|
class A7,
|
|
class A8,
|
|
class A9,
|
|
class A10,
|
|
class A11,
|
|
class A12,
|
|
class A13,
|
|
class A14,
|
|
class A15,
|
|
class R> class std_arity15pmf:
|
|
public std_arity15_mf<Object,
|
|
A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
A7,
|
|
A8,
|
|
A9,
|
|
A10,
|
|
A11,
|
|
A12,
|
|
A13,
|
|
A14,
|
|
A15,
|
|
R>,
|
|
public std_arity0pmf<Object, R> {
|
|
public:
|
|
typedef arity15_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
A7,
|
|
A8,
|
|
A9,
|
|
A10,
|
|
A11,
|
|
A12,
|
|
A13,
|
|
A14,
|
|
A15,
|
|
R>::result_type result_type;
|
|
typedef arity15_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
A7,
|
|
A8,
|
|
A9,
|
|
A10,
|
|
A11,
|
|
A12,
|
|
A13,
|
|
A14,
|
|
A15,
|
|
R>::first_argument_type first_argument_type;
|
|
typedef arity15_function<A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
A7,
|
|
A8,
|
|
A9,
|
|
A10,
|
|
A11,
|
|
A12,
|
|
A13,
|
|
A14,
|
|
A15,
|
|
R>::second_argument_type second_argument_type;
|
|
typedef std_arity15_mf<Object,
|
|
A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
A7,
|
|
A8,
|
|
A9,
|
|
A10,
|
|
A11,
|
|
A12,
|
|
A13,
|
|
A14,
|
|
A15,
|
|
R>::object_type object_type;
|
|
explicit inline std_arity15pmf(pmf15type pmfi) :
|
|
std_arity0pmf<Object, R>(reinterpret_cast<pmf0type>(pmfi)) {}
|
|
inline std_arity15pmf(const std_arity15pmf& pmfi) : std_arity0pmf<Object, R>(pmfi) {}
|
|
inline virtual R operator()(Object& o, A1 a1,
|
|
A2 a2,
|
|
A3 a3,
|
|
A4 a4,
|
|
A5 a5,
|
|
A6 a6,
|
|
A7 a7,
|
|
A8 a8,
|
|
A9 a9,
|
|
A10 a10,
|
|
A11 a11,
|
|
A12 a12,
|
|
A13 a13,
|
|
A14 a14,
|
|
A15 a15) const {
|
|
pmf15type pmf = reinterpret_cast<pmf15type>(pmf0);
|
|
return (o.*pmf)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
|
|
}
|
|
};
|
|
|
|
// Template Function for arity 15 pmf storage
|
|
template<class Object,
|
|
class A1,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6,
|
|
class A7,
|
|
class A8,
|
|
class A9,
|
|
class A10,
|
|
class A11,
|
|
class A12,
|
|
class A13,
|
|
class A14,
|
|
class A15,
|
|
class R> inline std_arity15pmf<Object,
|
|
A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
A7,
|
|
A8,
|
|
A9,
|
|
A10,
|
|
A11,
|
|
A12,
|
|
A13,
|
|
A14,
|
|
A15,
|
|
R>
|
|
std_arity15_member(R ( __stdcall Object::*const pmfi)(A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
A7,
|
|
A8,
|
|
A9,
|
|
A10,
|
|
A11,
|
|
A12,
|
|
A13,
|
|
A14,
|
|
A15)) {
|
|
return std_arity15pmf<Object,
|
|
A1,
|
|
A2,
|
|
A3,
|
|
A4,
|
|
A5,
|
|
A6,
|
|
A7,
|
|
A8,
|
|
A9,
|
|
A10,
|
|
A11,
|
|
A12,
|
|
A13,
|
|
A14,
|
|
A15,
|
|
R>(pmfi);
|
|
};
|
|
|
|
|
|
// Template Class for arity 15 obj&pmf ref storage
|
|
template<class Function> class std_arity15opmf:
|
|
public std_arity15pmf<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type,
|
|
Function::argument_7_type,
|
|
Function::argument_8_type,
|
|
Function::argument_9_type,
|
|
Function::argument_10_type,
|
|
Function::argument_11_type,
|
|
Function::argument_12_type,
|
|
Function::argument_13_type,
|
|
Function::argument_14_type,
|
|
Function::argument_15_type,
|
|
Function::result_type>,
|
|
public store_object<Function::object_type&> {
|
|
public:
|
|
explicit inline std_arity15opmf(Function::object_type& oi, const Function &f) :
|
|
store_object<Function::object_type&>(oi), std_arity15pmf<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type,
|
|
Function::argument_7_type,
|
|
Function::argument_8_type,
|
|
Function::argument_9_type,
|
|
Function::argument_10_type,
|
|
Function::argument_11_type,
|
|
Function::argument_12_type,
|
|
Function::argument_13_type,
|
|
Function::argument_14_type,
|
|
Function::argument_15_type,
|
|
Function::result_type>(f) {}
|
|
explicit inline std_arity15opmf(Function::object_type& oi, pmf15type pmfi) :
|
|
store_object<Function::object_type&>(oi), std_arity15pmf<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type,
|
|
Function::argument_7_type,
|
|
Function::argument_8_type,
|
|
Function::argument_9_type,
|
|
Function::argument_10_type,
|
|
Function::argument_11_type,
|
|
Function::argument_12_type,
|
|
Function::argument_13_type,
|
|
Function::argument_14_type,
|
|
Function::argument_15_type,
|
|
Function::result_type>(pmfi) {}
|
|
inline std_arity15opmf(const std_arity15opmf& bndri) :
|
|
store_object<Function::object_type&>(bndri), std_arity15pmf<Function::object_type,
|
|
Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type,
|
|
Function::argument_7_type,
|
|
Function::argument_8_type,
|
|
Function::argument_9_type,
|
|
Function::argument_10_type,
|
|
Function::argument_11_type,
|
|
Function::argument_12_type,
|
|
Function::argument_13_type,
|
|
Function::argument_14_type,
|
|
Function::argument_15_type,
|
|
Function::result_type>(bndri) {}
|
|
inline Function::result_type operator()(Function::first_argument_type a1,
|
|
Function::second_argument_type a2,
|
|
Function::argument_3_type a3,
|
|
Function::argument_4_type a4,
|
|
Function::argument_5_type a5,
|
|
Function::argument_6_type a6,
|
|
Function::argument_7_type a7,
|
|
Function::argument_8_type a8,
|
|
Function::argument_9_type a9,
|
|
Function::argument_10_type a10,
|
|
Function::argument_11_type a11,
|
|
Function::argument_12_type a12,
|
|
Function::argument_13_type a13,
|
|
Function::argument_14_type a14,
|
|
Function::argument_15_type a15) const {
|
|
pmf15type pmf = reinterpret_cast<pmf15type>(pmf0);
|
|
return (objval.*pmf)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
|
|
}
|
|
};
|
|
|
|
|
|
// Template Function for arity 15 obj&pmf ref storage
|
|
template<class Function, class Object> inline std_arity15opmf<Function>
|
|
std_arity15_member_obj(Object& oi, const Function &f) {
|
|
return std_arity15opmf<Function>(Function::object_type(oi), Function::pmf15type(f.pmf0));
|
|
};
|
|
|
|
|
|
|
|
///////////////////////////////////////////
|
|
// Binders
|
|
///////////////////////////////////////////
|
|
|
|
//
|
|
// binders for arity 2
|
|
//
|
|
|
|
|
|
// Template Classes for binding arity 2 to arity 1
|
|
|
|
|
|
// Template Classes for binding function ptrs of arity 2 to arity 1
|
|
|
|
template<class Function> class bndr_2 :
|
|
public arity1fp<Function::first_argument_type, Function::result_type> {
|
|
public:
|
|
typedef Function::result_type (*const pf2type) (Function::first_argument_type, Function::second_argument_type);
|
|
explicit inline bndr_2(const Function &f, Function::second_argument_type a2) :
|
|
arity1fp<Function::first_argument_type, Function::result_type>(reinterpret_cast<pf1type>(f.pf0)), arg2val(a2) {}
|
|
inline bndr_2(const bndr_2& bndri) :
|
|
arity1fp<Function::first_argument_type, Function::result_type>(reinterpret_cast<pf1type>(bndri.pf0)), arg2val(bndri.arg2val) {}
|
|
inline Function::result_type operator()(Function::first_argument_type a1) const {
|
|
pf2type pf = reinterpret_cast<pf2type>(pf0);
|
|
return pf(a1, arg2val);
|
|
}
|
|
public:
|
|
Function::second_argument_type arg2val;
|
|
};
|
|
|
|
template<class Function> class bndr_1 :
|
|
public arity1fp<Function::second_argument_type, Function::result_type> {
|
|
public:
|
|
typedef Function::result_type (*const pf2type) (Function::first_argument_type, Function::second_argument_type);
|
|
explicit inline bndr_1(const Function &f, Function::first_argument_type a1) :
|
|
arity1fp<Function::second_argument_type, Function::result_type>(reinterpret_cast<pf1type>(f.pf0)), arg1val(a1) {}
|
|
inline bndr_1(const bndr_1& bndri) :
|
|
arity1fp<Function::second_argument_type, Function::result_type>(reinterpret_cast<pf1type>(bndri.pf0)), arg1val(bndri.arg1val) {}
|
|
inline Function::result_type operator()(Function::second_argument_type a2) const {
|
|
pf2type pf = reinterpret_cast<pf2type>(pf0);
|
|
return pf(arg1val, a2);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
};
|
|
|
|
|
|
|
|
// Template Classes for binding pmf of arity 2 to arity 1
|
|
|
|
template<class Function> class bndr_mf_2 :
|
|
public arity1pmf<Function::object_type, Function::first_argument_type, Function::result_type>,
|
|
private arity2_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type, Function::result_type> {
|
|
public:
|
|
explicit inline bndr_mf_2(const Function &f, Function::second_argument_type a2) :
|
|
arity1pmf<Function::object_type, Function::first_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(f.pmf0)), arity2_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type, Function::result_type>(f), arg2val(a2) {}
|
|
inline bndr_mf_2(const bndr_mf_2& bndri) :
|
|
arity1pmf<Function::object_type, Function::first_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(bndri.pmf0)), arity2_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type, Function::result_type>(bndri), arg2val(bndri.arg2val) {}
|
|
inline virtual Function::result_type operator()(Function::object_type& o, Function::first_argument_type a1) const {
|
|
pmf2type pmf = reinterpret_cast<pmf2type>(pmf0);
|
|
return (o.*pmf)(a1, arg2val);
|
|
}
|
|
public:
|
|
Function::second_argument_type arg2val;
|
|
};
|
|
|
|
template<class Function> class bndr_mf_1 :
|
|
public arity1pmf<Function::object_type, Function::second_argument_type, Function::result_type>,
|
|
private arity2_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type, Function::result_type> {
|
|
public:
|
|
explicit inline bndr_mf_1(const Function &f, Function::first_argument_type a1) :
|
|
arity1pmf<Function::object_type, Function::second_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(f.pmf0)), arity2_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type, Function::result_type>(f), arg1val(a1) {}
|
|
inline bndr_mf_1(const bndr_mf_1& bndri) :
|
|
arity1pmf<Function::object_type, Function::second_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(bndri.pmf0)), arity2_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type, Function::result_type>(bndri), arg1val(bndri.arg1val) {}
|
|
inline virtual Function::result_type operator()(Function::object_type& o, Function::second_argument_type a2) const {
|
|
pmf2type pmf = reinterpret_cast<pmf2type>(pmf0);
|
|
return (o.*pmf)(arg1val, a2);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
};
|
|
|
|
|
|
|
|
// Template Classes for binding const pmf of arity 2 to arity 1
|
|
|
|
template<class Function> class bndr_const_mf_2 :
|
|
public arity1pmf_const<Function::object_type, Function::first_argument_type, Function::result_type>,
|
|
private arity2_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type, Function::result_type> {
|
|
public:
|
|
explicit inline bndr_const_mf_2(const Function &f, Function::second_argument_type a2) :
|
|
arity1pmf_const<Function::object_type, Function::first_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(f.pmf0)), arity2_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type, Function::result_type>(f), arg2val(a2) {}
|
|
inline bndr_const_mf_2(const bndr_const_mf_2& bndri) :
|
|
arity1pmf_const<Function::object_type, Function::first_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(bndri.pmf0)), arity2_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type, Function::result_type>(bndri), arg2val(bndri.arg2val) {}
|
|
inline virtual Function::result_type operator()(Function::object_type& o, Function::first_argument_type a1) const {
|
|
pmf2type pmf = reinterpret_cast<pmf2type>(pmf0);
|
|
return (o.*pmf)(a1, arg2val);
|
|
}
|
|
public:
|
|
Function::second_argument_type arg2val;
|
|
};
|
|
|
|
template<class Function> class bndr_const_mf_1 :
|
|
public arity1pmf_const<Function::object_type, Function::second_argument_type, Function::result_type>,
|
|
private arity2_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type, Function::result_type> {
|
|
public:
|
|
explicit inline bndr_const_mf_1(const Function &f, Function::first_argument_type a1) :
|
|
arity1pmf_const<Function::object_type, Function::second_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(f.pmf0)), arity2_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type, Function::result_type>(f), arg1val(a1) {}
|
|
inline bndr_const_mf_1(const bndr_const_mf_1& bndri) :
|
|
arity1pmf_const<Function::object_type, Function::second_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(bndri.pmf0)), arity2_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type, Function::result_type>(bndri), arg1val(bndri.arg1val) {}
|
|
inline virtual Function::result_type operator()(Function::object_type& o, Function::second_argument_type a2) const {
|
|
pmf2type pmf = reinterpret_cast<pmf2type>(pmf0);
|
|
return (o.*pmf)(arg1val, a2);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
};
|
|
|
|
|
|
|
|
// Template Classes for binding obj&pmf Ref of arity 2 to arity 1
|
|
|
|
template<class Function> class bndr_obj_2 :
|
|
public arity1opmf<Function>,
|
|
private arity2_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type, Function::result_type> {
|
|
public:
|
|
explicit inline bndr_obj_2(Function::object_type& oi, const Function &f, Function::second_argument_type a2) :
|
|
arity1opmf<Function>(oi, reinterpret_cast<pmf1type>(f.pmf0)), arity2_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type, Function::result_type>(f), arg2val(a2) {}
|
|
inline bndr_obj_2(const bndr_obj_2& bndri) :
|
|
arity1opmf<Function>(bndri.objval, reinterpret_cast<pmf1type>(bndri.pmf0)), arity2_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type, Function::result_type>(bndri), arg2val(bndri.arg2val) {}
|
|
inline Function::result_type operator()(Function::first_argument_type a1) const {
|
|
pmf2type pmf = reinterpret_cast<pmf2type>(pmf0);
|
|
return (objval.*pmf)(a1, arg2val);
|
|
}
|
|
public:
|
|
Function::second_argument_type arg2val;
|
|
};
|
|
|
|
template<class Function> class bndr_obj_1 :
|
|
public arity1opmf<Function>,
|
|
private arity2_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type, Function::result_type> {
|
|
public:
|
|
explicit inline bndr_obj_1(Function::object_type& oi, const Function &f, Function::first_argument_type a1) :
|
|
arity1opmf<Function>(oi, reinterpret_cast<pmf1type>(f.pmf0)), arity2_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type, Function::result_type>(f), arg1val(a1) {}
|
|
inline bndr_obj_1(const bndr_obj_1& bndri) :
|
|
arity1opmf<Function>(bndri.objval, reinterpret_cast<pmf1type>(bndri.pmf0)), arity2_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type, Function::result_type>(bndri), arg1val(bndri.arg1val) {}
|
|
inline Function::result_type operator()(Function::second_argument_type a2) const {
|
|
pmf2type pmf = reinterpret_cast<pmf2type>(pmf0);
|
|
return (objval.*pmf)(arg1val, a2);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
};
|
|
|
|
|
|
|
|
// Template Classes for binding const obj&pmf Ref of arity 2 to arity 1
|
|
|
|
template<class Function> class bndr_const_obj_2 :
|
|
public arity1opmf_const<Function>,
|
|
private arity2_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type, Function::result_type> {
|
|
public:
|
|
explicit inline bndr_const_obj_2(const Function::object_type& oi, const Function &f, Function::second_argument_type a2) :
|
|
arity1opmf_const<Function>(oi, reinterpret_cast<pmf1type>(f.pmf0)), arity2_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type, Function::result_type>(f), arg2val(a2) {}
|
|
inline bndr_const_obj_2(const bndr_const_obj_2& bndri) :
|
|
arity1opmf_const<Function>(bndri.objval, reinterpret_cast<pmf1type>(bndri.pmf0)), arity2_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type, Function::result_type>(bndri), arg2val(bndri.arg2val) {}
|
|
inline Function::result_type operator()(Function::first_argument_type a1) const {
|
|
pmf2type pmf = reinterpret_cast<pmf2type>(pmf0);
|
|
return (objval.*pmf)(a1, arg2val);
|
|
}
|
|
public:
|
|
Function::second_argument_type arg2val;
|
|
};
|
|
|
|
template<class Function> class bndr_const_obj_1 :
|
|
public arity1opmf_const<Function>,
|
|
private arity2_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type, Function::result_type> {
|
|
public:
|
|
explicit inline bndr_const_obj_1(const Function::object_type& oi, const Function &f, Function::first_argument_type a1) :
|
|
arity1opmf_const<Function>(oi, reinterpret_cast<pmf1type>(f.pmf0)), arity2_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type, Function::result_type>(f), arg1val(a1) {}
|
|
inline bndr_const_obj_1(const bndr_const_obj_1& bndri) :
|
|
arity1opmf_const<Function>(bndri.objval, reinterpret_cast<pmf1type>(bndri.pmf0)), arity2_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type, Function::result_type>(bndri), arg1val(bndri.arg1val) {}
|
|
inline Function::result_type operator()(Function::second_argument_type a2) const {
|
|
pmf2type pmf = reinterpret_cast<pmf2type>(pmf0);
|
|
return (objval.*pmf)(arg1val, a2);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
};
|
|
|
|
|
|
|
|
// Template Functions for binding arity 2 to arity 1
|
|
|
|
|
|
// Template Functions for binding function ptrs of arity 2 to arity 1
|
|
|
|
template<class Function, class A2> inline bndr_2<Function>
|
|
bind_fp_2(const Function &f, A2 a2) {
|
|
return bndr_2<Function>(f, Function::second_argument_type(a2));
|
|
};
|
|
|
|
template<class Function, class A1> inline bndr_1<Function>
|
|
bind_fp_1(const Function &f, A1 a1) {
|
|
return bndr_1<Function>(f, Function::first_argument_type(a1));
|
|
};
|
|
|
|
|
|
|
|
// Template Functions for binding pmf of arity 2 to arity 1
|
|
|
|
template<class Function, class A2> inline bndr_mf_2<Function>
|
|
bind_mf_2(const Function &f, A2 a2) {
|
|
return bndr_mf_2<Function>(f, Function::second_argument_type(a2));
|
|
};
|
|
|
|
template<class Function, class A1> inline bndr_mf_1<Function>
|
|
bind_mf_1(const Function &f, A1 a1) {
|
|
return bndr_mf_1<Function>(f, Function::first_argument_type(a1));
|
|
};
|
|
|
|
|
|
|
|
// Template Functions for binding const pmf of arity 2 to arity 1
|
|
|
|
template<class Function, class A2> inline bndr_const_mf_2<Function>
|
|
bind_const_mf_2(const Function &f, A2 a2) {
|
|
return bndr_const_mf_2<Function>(f, Function::second_argument_type(a2));
|
|
};
|
|
|
|
template<class Function, class A1> inline bndr_const_mf_1<Function>
|
|
bind_const_mf_1(const Function &f, A1 a1) {
|
|
return bndr_const_mf_1<Function>(f, Function::first_argument_type(a1));
|
|
};
|
|
|
|
|
|
|
|
// Template Functions for binding obj&pmf Ref of arity 2 to arity 1
|
|
|
|
template<class Function, class Object,
|
|
class A2> inline bndr_obj_2<Function>
|
|
bind_obj_2(Object& oi, const Function &f, A2 a2) {
|
|
return bndr_obj_2<Function>(static_cast<Function::object_type&>(oi), f, Function::second_argument_type(a2));
|
|
};
|
|
|
|
template<class Function, class Object,
|
|
class A1> inline bndr_obj_1<Function>
|
|
bind_obj_1(Object& oi, const Function &f, A1 a1) {
|
|
return bndr_obj_1<Function>(static_cast<Function::object_type&>(oi), f, Function::first_argument_type(a1));
|
|
};
|
|
|
|
|
|
|
|
// Template Functions for binding const obj&pmf Ref of arity 2 to arity 1
|
|
|
|
template<class Function, const class Object,
|
|
class A2> inline bndr_const_obj_2<Function>
|
|
bind_const_obj_2(const Object& oi, const Function &f, A2 a2) {
|
|
return bndr_const_obj_2<Function>(static_cast<Function::object_type&>(oi), f, Function::second_argument_type(a2));
|
|
};
|
|
|
|
template<class Function, const class Object,
|
|
class A1> inline bndr_const_obj_1<Function>
|
|
bind_const_obj_1(const Object& oi, const Function &f, A1 a1) {
|
|
return bndr_const_obj_1<Function>(static_cast<Function::object_type&>(oi), f, Function::first_argument_type(a1));
|
|
};
|
|
|
|
|
|
|
|
//
|
|
// binders for arity 3
|
|
//
|
|
|
|
|
|
// Template Classes for binding arity 3 to arity 1
|
|
|
|
|
|
// Template Classes for binding function ptrs of arity 3 to arity 1
|
|
|
|
template<class Function> class bndr_2_3 :
|
|
public arity1fp<Function::first_argument_type, Function::result_type> {
|
|
public:
|
|
typedef Function::result_type (*const pf3type) (Function::first_argument_type, Function::second_argument_type, Function::argument_3_type);
|
|
explicit inline bndr_2_3(const Function &f, Function::second_argument_type a2,
|
|
Function::argument_3_type a3) :
|
|
arity1fp<Function::first_argument_type, Function::result_type>(reinterpret_cast<pf1type>(f.pf0)), arg2val(a2), arg3val(a3) {}
|
|
inline bndr_2_3(const bndr_2_3& bndri) :
|
|
arity1fp<Function::first_argument_type, Function::result_type>(reinterpret_cast<pf1type>(bndri.pf0)), arg2val(bndri.arg2val), arg3val(bndri.arg3val) {}
|
|
inline Function::result_type operator()(Function::first_argument_type a1) const {
|
|
pf3type pf = reinterpret_cast<pf3type>(pf0);
|
|
return pf(a1, arg2val, arg3val);
|
|
}
|
|
public:
|
|
Function::second_argument_type arg2val;
|
|
Function::argument_3_type arg3val;
|
|
};
|
|
|
|
template<class Function> class bndr_1_3 :
|
|
public arity1fp<Function::second_argument_type, Function::result_type> {
|
|
public:
|
|
typedef Function::result_type (*const pf3type) (Function::first_argument_type, Function::second_argument_type, Function::argument_3_type);
|
|
explicit inline bndr_1_3(const Function &f, Function::first_argument_type a1,
|
|
Function::argument_3_type a3) :
|
|
arity1fp<Function::second_argument_type, Function::result_type>(reinterpret_cast<pf1type>(f.pf0)), arg1val(a1), arg3val(a3) {}
|
|
inline bndr_1_3(const bndr_1_3& bndri) :
|
|
arity1fp<Function::second_argument_type, Function::result_type>(reinterpret_cast<pf1type>(bndri.pf0)), arg1val(bndri.arg1val), arg3val(bndri.arg3val) {}
|
|
inline Function::result_type operator()(Function::second_argument_type a2) const {
|
|
pf3type pf = reinterpret_cast<pf3type>(pf0);
|
|
return pf(arg1val, a2, arg3val);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::argument_3_type arg3val;
|
|
};
|
|
|
|
template<class Function> class bndr_1_2 :
|
|
public arity1fp<Function::argument_3_type, Function::result_type> {
|
|
public:
|
|
typedef Function::result_type (*const pf3type) (Function::first_argument_type, Function::second_argument_type, Function::argument_3_type);
|
|
explicit inline bndr_1_2(const Function &f, Function::first_argument_type a1,
|
|
Function::second_argument_type a2) :
|
|
arity1fp<Function::argument_3_type, Function::result_type>(reinterpret_cast<pf1type>(f.pf0)), arg1val(a1), arg2val(a2) {}
|
|
inline bndr_1_2(const bndr_1_2& bndri) :
|
|
arity1fp<Function::argument_3_type, Function::result_type>(reinterpret_cast<pf1type>(bndri.pf0)), arg1val(bndri.arg1val), arg2val(bndri.arg2val) {}
|
|
inline Function::result_type operator()(Function::argument_3_type a3) const {
|
|
pf3type pf = reinterpret_cast<pf3type>(pf0);
|
|
return pf(arg1val, arg2val, a3);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::second_argument_type arg2val;
|
|
};
|
|
|
|
|
|
|
|
// Template Classes for binding pmf of arity 3 to arity 1
|
|
|
|
template<class Function> class bndr_mf_2_3 :
|
|
public arity1pmf<Function::object_type, Function::first_argument_type, Function::result_type>,
|
|
private arity3_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type> {
|
|
public:
|
|
explicit inline bndr_mf_2_3(const Function &f, Function::second_argument_type a2, Function::argument_3_type a3) :
|
|
arity1pmf<Function::object_type, Function::first_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(f.pmf0)), arity3_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type>(f), arg2val(a2), arg3val(a3) {}
|
|
inline bndr_mf_2_3(const bndr_mf_2_3& bndri) :
|
|
arity1pmf<Function::object_type, Function::first_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(bndri.pmf0)), arity3_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type>(bndri), arg2val(bndri.arg2val), arg3val(bndri.arg3val) {}
|
|
inline virtual Function::result_type operator()(Function::object_type& o, Function::first_argument_type a1) const {
|
|
pmf3type pmf = reinterpret_cast<pmf3type>(pmf0);
|
|
return (o.*pmf)(a1, arg2val, arg3val);
|
|
}
|
|
public:
|
|
Function::second_argument_type arg2val;
|
|
Function::argument_3_type arg3val;
|
|
};
|
|
|
|
template<class Function> class bndr_mf_1_3 :
|
|
public arity1pmf<Function::object_type, Function::second_argument_type, Function::result_type>,
|
|
private arity3_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type> {
|
|
public:
|
|
explicit inline bndr_mf_1_3(const Function &f, Function::first_argument_type a1, Function::argument_3_type a3) :
|
|
arity1pmf<Function::object_type, Function::second_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(f.pmf0)), arity3_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type>(f), arg1val(a1), arg3val(a3) {}
|
|
inline bndr_mf_1_3(const bndr_mf_1_3& bndri) :
|
|
arity1pmf<Function::object_type, Function::second_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(bndri.pmf0)), arity3_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type>(bndri), arg1val(bndri.arg1val), arg3val(bndri.arg3val) {}
|
|
inline virtual Function::result_type operator()(Function::object_type& o, Function::second_argument_type a2) const {
|
|
pmf3type pmf = reinterpret_cast<pmf3type>(pmf0);
|
|
return (o.*pmf)(arg1val, a2, arg3val);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::argument_3_type arg3val;
|
|
};
|
|
|
|
template<class Function> class bndr_mf_1_2 :
|
|
public arity1pmf<Function::object_type, Function::argument_3_type, Function::result_type>,
|
|
private arity3_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type> {
|
|
public:
|
|
explicit inline bndr_mf_1_2(const Function &f, Function::first_argument_type a1, Function::second_argument_type a2) :
|
|
arity1pmf<Function::object_type, Function::argument_3_type, Function::result_type>(reinterpret_cast<pmf1type>(f.pmf0)), arity3_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type>(f), arg1val(a1), arg2val(a2) {}
|
|
inline bndr_mf_1_2(const bndr_mf_1_2& bndri) :
|
|
arity1pmf<Function::object_type, Function::argument_3_type, Function::result_type>(reinterpret_cast<pmf1type>(bndri.pmf0)), arity3_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type>(bndri), arg1val(bndri.arg1val), arg2val(bndri.arg2val) {}
|
|
inline virtual Function::result_type operator()(Function::object_type& o, Function::argument_3_type a3) const {
|
|
pmf3type pmf = reinterpret_cast<pmf3type>(pmf0);
|
|
return (o.*pmf)(arg1val, arg2val, a3);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::second_argument_type arg2val;
|
|
};
|
|
|
|
|
|
|
|
// Template Classes for binding const pmf of arity 3 to arity 1
|
|
|
|
template<class Function> class bndr_const_mf_2_3 :
|
|
public arity1pmf_const<Function::object_type, Function::first_argument_type, Function::result_type>,
|
|
private arity3_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type> {
|
|
public:
|
|
explicit inline bndr_const_mf_2_3(const Function &f, Function::second_argument_type a2, Function::argument_3_type a3) :
|
|
arity1pmf_const<Function::object_type, Function::first_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(f.pmf0)), arity3_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type>(f), arg2val(a2), arg3val(a3) {}
|
|
inline bndr_const_mf_2_3(const bndr_const_mf_2_3& bndri) :
|
|
arity1pmf_const<Function::object_type, Function::first_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(bndri.pmf0)), arity3_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type>(bndri), arg2val(bndri.arg2val), arg3val(bndri.arg3val) {}
|
|
inline virtual Function::result_type operator()(Function::object_type& o, Function::first_argument_type a1) const {
|
|
pmf3type pmf = reinterpret_cast<pmf3type>(pmf0);
|
|
return (o.*pmf)(a1, arg2val, arg3val);
|
|
}
|
|
public:
|
|
Function::second_argument_type arg2val;
|
|
Function::argument_3_type arg3val;
|
|
};
|
|
|
|
template<class Function> class bndr_const_mf_1_3 :
|
|
public arity1pmf_const<Function::object_type, Function::second_argument_type, Function::result_type>,
|
|
private arity3_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type> {
|
|
public:
|
|
explicit inline bndr_const_mf_1_3(const Function &f, Function::first_argument_type a1, Function::argument_3_type a3) :
|
|
arity1pmf_const<Function::object_type, Function::second_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(f.pmf0)), arity3_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type>(f), arg1val(a1), arg3val(a3) {}
|
|
inline bndr_const_mf_1_3(const bndr_const_mf_1_3& bndri) :
|
|
arity1pmf_const<Function::object_type, Function::second_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(bndri.pmf0)), arity3_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type>(bndri), arg1val(bndri.arg1val), arg3val(bndri.arg3val) {}
|
|
inline virtual Function::result_type operator()(Function::object_type& o, Function::second_argument_type a2) const {
|
|
pmf3type pmf = reinterpret_cast<pmf3type>(pmf0);
|
|
return (o.*pmf)(arg1val, a2, arg3val);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::argument_3_type arg3val;
|
|
};
|
|
|
|
template<class Function> class bndr_const_mf_1_2 :
|
|
public arity1pmf_const<Function::object_type, Function::argument_3_type, Function::result_type>,
|
|
private arity3_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type> {
|
|
public:
|
|
explicit inline bndr_const_mf_1_2(const Function &f, Function::first_argument_type a1, Function::second_argument_type a2) :
|
|
arity1pmf_const<Function::object_type, Function::argument_3_type, Function::result_type>(reinterpret_cast<pmf1type>(f.pmf0)), arity3_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type>(f), arg1val(a1), arg2val(a2) {}
|
|
inline bndr_const_mf_1_2(const bndr_const_mf_1_2& bndri) :
|
|
arity1pmf_const<Function::object_type, Function::argument_3_type, Function::result_type>(reinterpret_cast<pmf1type>(bndri.pmf0)), arity3_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type>(bndri), arg1val(bndri.arg1val), arg2val(bndri.arg2val) {}
|
|
inline virtual Function::result_type operator()(Function::object_type& o, Function::argument_3_type a3) const {
|
|
pmf3type pmf = reinterpret_cast<pmf3type>(pmf0);
|
|
return (o.*pmf)(arg1val, arg2val, a3);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::second_argument_type arg2val;
|
|
};
|
|
|
|
|
|
|
|
// Template Classes for binding obj&pmf Ref of arity 3 to arity 1
|
|
|
|
template<class Function> class bndr_obj_2_3 :
|
|
public arity1opmf<Function>,
|
|
private arity3_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type> {
|
|
public:
|
|
explicit inline bndr_obj_2_3(Function::object_type& oi, const Function &f, Function::second_argument_type a2, Function::argument_3_type a3) :
|
|
arity1opmf<Function>(oi, reinterpret_cast<pmf1type>(f.pmf0)), arity3_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type>(f), arg2val(a2), arg3val(a3) {}
|
|
inline bndr_obj_2_3(const bndr_obj_2_3& bndri) :
|
|
arity1opmf<Function>(bndri.objval, reinterpret_cast<pmf1type>(bndri.pmf0)), arity3_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type>(bndri), arg2val(bndri.arg2val), arg3val(bndri.arg3val) {}
|
|
inline Function::result_type operator()(Function::first_argument_type a1) const {
|
|
pmf3type pmf = reinterpret_cast<pmf3type>(pmf0);
|
|
return (objval.*pmf)(a1, arg2val, arg3val);
|
|
}
|
|
public:
|
|
Function::second_argument_type arg2val;
|
|
Function::argument_3_type arg3val;
|
|
};
|
|
|
|
template<class Function> class bndr_obj_1_3 :
|
|
public arity1opmf<Function>,
|
|
private arity3_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type> {
|
|
public:
|
|
explicit inline bndr_obj_1_3(Function::object_type& oi, const Function &f, Function::first_argument_type a1, Function::argument_3_type a3) :
|
|
arity1opmf<Function>(oi, reinterpret_cast<pmf1type>(f.pmf0)), arity3_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type>(f), arg1val(a1), arg3val(a3) {}
|
|
inline bndr_obj_1_3(const bndr_obj_1_3& bndri) :
|
|
arity1opmf<Function>(bndri.objval, reinterpret_cast<pmf1type>(bndri.pmf0)), arity3_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type>(bndri), arg1val(bndri.arg1val), arg3val(bndri.arg3val) {}
|
|
inline Function::result_type operator()(Function::second_argument_type a2) const {
|
|
pmf3type pmf = reinterpret_cast<pmf3type>(pmf0);
|
|
return (objval.*pmf)(arg1val, a2, arg3val);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::argument_3_type arg3val;
|
|
};
|
|
|
|
template<class Function> class bndr_obj_1_2 :
|
|
public arity1opmf<Function>,
|
|
private arity3_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type> {
|
|
public:
|
|
explicit inline bndr_obj_1_2(Function::object_type& oi, const Function &f, Function::first_argument_type a1, Function::second_argument_type a2) :
|
|
arity1opmf<Function>(oi, reinterpret_cast<pmf1type>(f.pmf0)), arity3_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type>(f), arg1val(a1), arg2val(a2) {}
|
|
inline bndr_obj_1_2(const bndr_obj_1_2& bndri) :
|
|
arity1opmf<Function>(bndri.objval, reinterpret_cast<pmf1type>(bndri.pmf0)), arity3_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type>(bndri), arg1val(bndri.arg1val), arg2val(bndri.arg2val) {}
|
|
inline Function::result_type operator()(Function::argument_3_type a3) const {
|
|
pmf3type pmf = reinterpret_cast<pmf3type>(pmf0);
|
|
return (objval.*pmf)(arg1val, arg2val, a3);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::second_argument_type arg2val;
|
|
};
|
|
|
|
|
|
|
|
// Template Classes for binding const obj&pmf Ref of arity 3 to arity 1
|
|
|
|
template<class Function> class bndr_const_obj_2_3 :
|
|
public arity1opmf_const<Function>,
|
|
private arity3_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type> {
|
|
public:
|
|
explicit inline bndr_const_obj_2_3(const Function::object_type& oi, const Function &f, Function::second_argument_type a2, Function::argument_3_type a3) :
|
|
arity1opmf_const<Function>(oi, reinterpret_cast<pmf1type>(f.pmf0)), arity3_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type>(f), arg2val(a2), arg3val(a3) {}
|
|
inline bndr_const_obj_2_3(const bndr_const_obj_2_3& bndri) :
|
|
arity1opmf_const<Function>(bndri.objval, reinterpret_cast<pmf1type>(bndri.pmf0)), arity3_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type>(bndri), arg2val(bndri.arg2val), arg3val(bndri.arg3val) {}
|
|
inline Function::result_type operator()(Function::first_argument_type a1) const {
|
|
pmf3type pmf = reinterpret_cast<pmf3type>(pmf0);
|
|
return (objval.*pmf)(a1, arg2val, arg3val);
|
|
}
|
|
public:
|
|
Function::second_argument_type arg2val;
|
|
Function::argument_3_type arg3val;
|
|
};
|
|
|
|
template<class Function> class bndr_const_obj_1_3 :
|
|
public arity1opmf_const<Function>,
|
|
private arity3_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type> {
|
|
public:
|
|
explicit inline bndr_const_obj_1_3(const Function::object_type& oi, const Function &f, Function::first_argument_type a1, Function::argument_3_type a3) :
|
|
arity1opmf_const<Function>(oi, reinterpret_cast<pmf1type>(f.pmf0)), arity3_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type>(f), arg1val(a1), arg3val(a3) {}
|
|
inline bndr_const_obj_1_3(const bndr_const_obj_1_3& bndri) :
|
|
arity1opmf_const<Function>(bndri.objval, reinterpret_cast<pmf1type>(bndri.pmf0)), arity3_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type>(bndri), arg1val(bndri.arg1val), arg3val(bndri.arg3val) {}
|
|
inline Function::result_type operator()(Function::second_argument_type a2) const {
|
|
pmf3type pmf = reinterpret_cast<pmf3type>(pmf0);
|
|
return (objval.*pmf)(arg1val, a2, arg3val);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::argument_3_type arg3val;
|
|
};
|
|
|
|
template<class Function> class bndr_const_obj_1_2 :
|
|
public arity1opmf_const<Function>,
|
|
private arity3_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type> {
|
|
public:
|
|
explicit inline bndr_const_obj_1_2(const Function::object_type& oi, const Function &f, Function::first_argument_type a1, Function::second_argument_type a2) :
|
|
arity1opmf_const<Function>(oi, reinterpret_cast<pmf1type>(f.pmf0)), arity3_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type>(f), arg1val(a1), arg2val(a2) {}
|
|
inline bndr_const_obj_1_2(const bndr_const_obj_1_2& bndri) :
|
|
arity1opmf_const<Function>(bndri.objval, reinterpret_cast<pmf1type>(bndri.pmf0)), arity3_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type>(bndri), arg1val(bndri.arg1val), arg2val(bndri.arg2val) {}
|
|
inline Function::result_type operator()(Function::argument_3_type a3) const {
|
|
pmf3type pmf = reinterpret_cast<pmf3type>(pmf0);
|
|
return (objval.*pmf)(arg1val, arg2val, a3);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::second_argument_type arg2val;
|
|
};
|
|
|
|
|
|
|
|
// Template Functions for binding arity 3 to arity 1
|
|
|
|
|
|
// Template Functions for binding function ptrs of arity 3 to arity 1
|
|
|
|
template<class Function, class A2,
|
|
class A3> inline bndr_2_3<Function>
|
|
bind_fp_2_3(const Function &f, A2 a2,
|
|
A3 a3) {
|
|
return bndr_2_3<Function>(f, Function::second_argument_type(a2), Function::argument_3_type(a3));
|
|
};
|
|
|
|
template<class Function, class A1,
|
|
class A3> inline bndr_1_3<Function>
|
|
bind_fp_1_3(const Function &f, A1 a1,
|
|
A3 a3) {
|
|
return bndr_1_3<Function>(f, Function::first_argument_type(a1), Function::argument_3_type(a3));
|
|
};
|
|
|
|
template<class Function, class A1,
|
|
class A2> inline bndr_1_2<Function>
|
|
bind_fp_1_2(const Function &f, A1 a1,
|
|
A2 a2) {
|
|
return bndr_1_2<Function>(f, Function::first_argument_type(a1), Function::second_argument_type(a2));
|
|
};
|
|
|
|
|
|
|
|
// Template Functions for binding pmf of arity 3 to arity 1
|
|
|
|
template<class Function, class A2,
|
|
class A3> inline bndr_mf_2_3<Function>
|
|
bind_mf_2_3(const Function &f, A2 a2,
|
|
A3 a3) {
|
|
return bndr_mf_2_3<Function>(f, Function::second_argument_type(a2), Function::argument_3_type(a3));
|
|
};
|
|
|
|
template<class Function, class A1,
|
|
class A3> inline bndr_mf_1_3<Function>
|
|
bind_mf_1_3(const Function &f, A1 a1,
|
|
A3 a3) {
|
|
return bndr_mf_1_3<Function>(f, Function::first_argument_type(a1), Function::argument_3_type(a3));
|
|
};
|
|
|
|
template<class Function, class A1,
|
|
class A2> inline bndr_mf_1_2<Function>
|
|
bind_mf_1_2(const Function &f, A1 a1,
|
|
A2 a2) {
|
|
return bndr_mf_1_2<Function>(f, Function::first_argument_type(a1), Function::second_argument_type(a2));
|
|
};
|
|
|
|
|
|
|
|
// Template Functions for binding const pmf of arity 3 to arity 1
|
|
|
|
template<class Function, class A2,
|
|
class A3> inline bndr_const_mf_2_3<Function>
|
|
bind_const_mf_2_3(const Function &f, A2 a2,
|
|
A3 a3) {
|
|
return bndr_const_mf_2_3<Function>(f, Function::second_argument_type(a2), Function::argument_3_type(a3));
|
|
};
|
|
|
|
template<class Function, class A1,
|
|
class A3> inline bndr_const_mf_1_3<Function>
|
|
bind_const_mf_1_3(const Function &f, A1 a1,
|
|
A3 a3) {
|
|
return bndr_const_mf_1_3<Function>(f, Function::first_argument_type(a1), Function::argument_3_type(a3));
|
|
};
|
|
|
|
template<class Function, class A1,
|
|
class A2> inline bndr_const_mf_1_2<Function>
|
|
bind_const_mf_1_2(const Function &f, A1 a1,
|
|
A2 a2) {
|
|
return bndr_const_mf_1_2<Function>(f, Function::first_argument_type(a1), Function::second_argument_type(a2));
|
|
};
|
|
|
|
|
|
|
|
// Template Functions for binding obj&pmf Ref of arity 3 to arity 1
|
|
|
|
template<class Function, class Object,
|
|
class A2,
|
|
class A3> inline bndr_obj_2_3<Function>
|
|
bind_obj_2_3(Object& oi, const Function &f, A2 a2,
|
|
A3 a3) {
|
|
return bndr_obj_2_3<Function>(static_cast<Function::object_type&>(oi), f, Function::second_argument_type(a2), Function::argument_3_type(a3));
|
|
};
|
|
|
|
template<class Function, class Object,
|
|
class A1,
|
|
class A3> inline bndr_obj_1_3<Function>
|
|
bind_obj_1_3(Object& oi, const Function &f, A1 a1,
|
|
A3 a3) {
|
|
return bndr_obj_1_3<Function>(static_cast<Function::object_type&>(oi), f, Function::first_argument_type(a1), Function::argument_3_type(a3));
|
|
};
|
|
|
|
template<class Function, class Object,
|
|
class A1,
|
|
class A2> inline bndr_obj_1_2<Function>
|
|
bind_obj_1_2(Object& oi, const Function &f, A1 a1,
|
|
A2 a2) {
|
|
return bndr_obj_1_2<Function>(static_cast<Function::object_type&>(oi), f, Function::first_argument_type(a1), Function::second_argument_type(a2));
|
|
};
|
|
|
|
|
|
|
|
// Template Functions for binding const obj&pmf Ref of arity 3 to arity 1
|
|
|
|
template<class Function, const class Object,
|
|
class A2,
|
|
class A3> inline bndr_const_obj_2_3<Function>
|
|
bind_const_obj_2_3(const Object& oi, const Function &f, A2 a2,
|
|
A3 a3) {
|
|
return bndr_const_obj_2_3<Function>(static_cast<Function::object_type&>(oi), f, Function::second_argument_type(a2), Function::argument_3_type(a3));
|
|
};
|
|
|
|
template<class Function, const class Object,
|
|
class A1,
|
|
class A3> inline bndr_const_obj_1_3<Function>
|
|
bind_const_obj_1_3(const Object& oi, const Function &f, A1 a1,
|
|
A3 a3) {
|
|
return bndr_const_obj_1_3<Function>(static_cast<Function::object_type&>(oi), f, Function::first_argument_type(a1), Function::argument_3_type(a3));
|
|
};
|
|
|
|
template<class Function, const class Object,
|
|
class A1,
|
|
class A2> inline bndr_const_obj_1_2<Function>
|
|
bind_const_obj_1_2(const Object& oi, const Function &f, A1 a1,
|
|
A2 a2) {
|
|
return bndr_const_obj_1_2<Function>(static_cast<Function::object_type&>(oi), f, Function::first_argument_type(a1), Function::second_argument_type(a2));
|
|
};
|
|
|
|
|
|
|
|
//
|
|
// binders for arity 4
|
|
//
|
|
|
|
|
|
// Template Classes for binding arity 4 to arity 1
|
|
|
|
|
|
// Template Classes for binding pmf of arity 4 to arity 1
|
|
|
|
template<class Function> class bndr_mf_2_3_4 :
|
|
public arity1pmf<Function::object_type, Function::first_argument_type, Function::result_type>,
|
|
private arity4_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type> {
|
|
public:
|
|
explicit inline bndr_mf_2_3_4(const Function &f, Function::second_argument_type a2, Function::argument_3_type a3, Function::argument_4_type a4) :
|
|
arity1pmf<Function::object_type, Function::first_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(f.pmf0)), arity4_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type>(f), arg2val(a2), arg3val(a3), arg4val(a4) {}
|
|
inline bndr_mf_2_3_4(const bndr_mf_2_3_4& bndri) :
|
|
arity1pmf<Function::object_type, Function::first_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(bndri.pmf0)), arity4_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type>(bndri), arg2val(bndri.arg2val), arg3val(bndri.arg3val), arg4val(bndri.arg4val) {}
|
|
inline virtual Function::result_type operator()(Function::object_type& o, Function::first_argument_type a1) const {
|
|
pmf4type pmf = reinterpret_cast<pmf4type>(pmf0);
|
|
return (o.*pmf)(a1, arg2val, arg3val, arg4val);
|
|
}
|
|
public:
|
|
Function::second_argument_type arg2val;
|
|
Function::argument_3_type arg3val;
|
|
Function::argument_4_type arg4val;
|
|
};
|
|
|
|
template<class Function> class bndr_mf_1_3_4 :
|
|
public arity1pmf<Function::object_type, Function::second_argument_type, Function::result_type>,
|
|
private arity4_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type> {
|
|
public:
|
|
explicit inline bndr_mf_1_3_4(const Function &f, Function::first_argument_type a1, Function::argument_3_type a3, Function::argument_4_type a4) :
|
|
arity1pmf<Function::object_type, Function::second_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(f.pmf0)), arity4_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type>(f), arg1val(a1), arg3val(a3), arg4val(a4) {}
|
|
inline bndr_mf_1_3_4(const bndr_mf_1_3_4& bndri) :
|
|
arity1pmf<Function::object_type, Function::second_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(bndri.pmf0)), arity4_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type>(bndri), arg1val(bndri.arg1val), arg3val(bndri.arg3val), arg4val(bndri.arg4val) {}
|
|
inline virtual Function::result_type operator()(Function::object_type& o, Function::second_argument_type a2) const {
|
|
pmf4type pmf = reinterpret_cast<pmf4type>(pmf0);
|
|
return (o.*pmf)(arg1val, a2, arg3val, arg4val);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::argument_3_type arg3val;
|
|
Function::argument_4_type arg4val;
|
|
};
|
|
|
|
template<class Function> class bndr_mf_1_2_4 :
|
|
public arity1pmf<Function::object_type, Function::argument_3_type, Function::result_type>,
|
|
private arity4_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type> {
|
|
public:
|
|
explicit inline bndr_mf_1_2_4(const Function &f, Function::first_argument_type a1, Function::second_argument_type a2, Function::argument_4_type a4) :
|
|
arity1pmf<Function::object_type, Function::argument_3_type, Function::result_type>(reinterpret_cast<pmf1type>(f.pmf0)), arity4_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type>(f), arg1val(a1), arg2val(a2), arg4val(a4) {}
|
|
inline bndr_mf_1_2_4(const bndr_mf_1_2_4& bndri) :
|
|
arity1pmf<Function::object_type, Function::argument_3_type, Function::result_type>(reinterpret_cast<pmf1type>(bndri.pmf0)), arity4_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type>(bndri), arg1val(bndri.arg1val), arg2val(bndri.arg2val), arg4val(bndri.arg4val) {}
|
|
inline virtual Function::result_type operator()(Function::object_type& o, Function::argument_3_type a3) const {
|
|
pmf4type pmf = reinterpret_cast<pmf4type>(pmf0);
|
|
return (o.*pmf)(arg1val, arg2val, a3, arg4val);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::second_argument_type arg2val;
|
|
Function::argument_4_type arg4val;
|
|
};
|
|
|
|
|
|
|
|
// Template Classes for binding const pmf of arity 4 to arity 1
|
|
|
|
template<class Function> class bndr_const_mf_2_3_4 :
|
|
public arity1pmf_const<Function::object_type, Function::first_argument_type, Function::result_type>,
|
|
private arity4_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type> {
|
|
public:
|
|
explicit inline bndr_const_mf_2_3_4(const Function &f, Function::second_argument_type a2, Function::argument_3_type a3, Function::argument_4_type a4) :
|
|
arity1pmf_const<Function::object_type, Function::first_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(f.pmf0)), arity4_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type>(f), arg2val(a2), arg3val(a3), arg4val(a4) {}
|
|
inline bndr_const_mf_2_3_4(const bndr_const_mf_2_3_4& bndri) :
|
|
arity1pmf_const<Function::object_type, Function::first_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(bndri.pmf0)), arity4_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type>(bndri), arg2val(bndri.arg2val), arg3val(bndri.arg3val), arg4val(bndri.arg4val) {}
|
|
inline virtual Function::result_type operator()(Function::object_type& o, Function::first_argument_type a1) const {
|
|
pmf4type pmf = reinterpret_cast<pmf4type>(pmf0);
|
|
return (o.*pmf)(a1, arg2val, arg3val, arg4val);
|
|
}
|
|
public:
|
|
Function::second_argument_type arg2val;
|
|
Function::argument_3_type arg3val;
|
|
Function::argument_4_type arg4val;
|
|
};
|
|
|
|
template<class Function> class bndr_const_mf_1_3_4 :
|
|
public arity1pmf_const<Function::object_type, Function::second_argument_type, Function::result_type>,
|
|
private arity4_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type> {
|
|
public:
|
|
explicit inline bndr_const_mf_1_3_4(const Function &f, Function::first_argument_type a1, Function::argument_3_type a3, Function::argument_4_type a4) :
|
|
arity1pmf_const<Function::object_type, Function::second_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(f.pmf0)), arity4_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type>(f), arg1val(a1), arg3val(a3), arg4val(a4) {}
|
|
inline bndr_const_mf_1_3_4(const bndr_const_mf_1_3_4& bndri) :
|
|
arity1pmf_const<Function::object_type, Function::second_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(bndri.pmf0)), arity4_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type>(bndri), arg1val(bndri.arg1val), arg3val(bndri.arg3val), arg4val(bndri.arg4val) {}
|
|
inline virtual Function::result_type operator()(Function::object_type& o, Function::second_argument_type a2) const {
|
|
pmf4type pmf = reinterpret_cast<pmf4type>(pmf0);
|
|
return (o.*pmf)(arg1val, a2, arg3val, arg4val);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::argument_3_type arg3val;
|
|
Function::argument_4_type arg4val;
|
|
};
|
|
|
|
template<class Function> class bndr_const_mf_1_2_4 :
|
|
public arity1pmf_const<Function::object_type, Function::argument_3_type, Function::result_type>,
|
|
private arity4_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type> {
|
|
public:
|
|
explicit inline bndr_const_mf_1_2_4(const Function &f, Function::first_argument_type a1, Function::second_argument_type a2, Function::argument_4_type a4) :
|
|
arity1pmf_const<Function::object_type, Function::argument_3_type, Function::result_type>(reinterpret_cast<pmf1type>(f.pmf0)), arity4_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type>(f), arg1val(a1), arg2val(a2), arg4val(a4) {}
|
|
inline bndr_const_mf_1_2_4(const bndr_const_mf_1_2_4& bndri) :
|
|
arity1pmf_const<Function::object_type, Function::argument_3_type, Function::result_type>(reinterpret_cast<pmf1type>(bndri.pmf0)), arity4_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type>(bndri), arg1val(bndri.arg1val), arg2val(bndri.arg2val), arg4val(bndri.arg4val) {}
|
|
inline virtual Function::result_type operator()(Function::object_type& o, Function::argument_3_type a3) const {
|
|
pmf4type pmf = reinterpret_cast<pmf4type>(pmf0);
|
|
return (o.*pmf)(arg1val, arg2val, a3, arg4val);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::second_argument_type arg2val;
|
|
Function::argument_4_type arg4val;
|
|
};
|
|
|
|
|
|
|
|
// Template Classes for binding obj&pmf Ref of arity 4 to arity 1
|
|
|
|
template<class Function> class bndr_obj_2_3_4 :
|
|
public arity1opmf<Function>,
|
|
private arity4_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type> {
|
|
public:
|
|
explicit inline bndr_obj_2_3_4(Function::object_type& oi, const Function &f, Function::second_argument_type a2, Function::argument_3_type a3, Function::argument_4_type a4) :
|
|
arity1opmf<Function>(oi, reinterpret_cast<pmf1type>(f.pmf0)), arity4_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type>(f), arg2val(a2), arg3val(a3), arg4val(a4) {}
|
|
inline bndr_obj_2_3_4(const bndr_obj_2_3_4& bndri) :
|
|
arity1opmf<Function>(bndri.objval, reinterpret_cast<pmf1type>(bndri.pmf0)), arity4_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type>(bndri), arg2val(bndri.arg2val), arg3val(bndri.arg3val), arg4val(bndri.arg4val) {}
|
|
inline Function::result_type operator()(Function::first_argument_type a1) const {
|
|
pmf4type pmf = reinterpret_cast<pmf4type>(pmf0);
|
|
return (objval.*pmf)(a1, arg2val, arg3val, arg4val);
|
|
}
|
|
public:
|
|
Function::second_argument_type arg2val;
|
|
Function::argument_3_type arg3val;
|
|
Function::argument_4_type arg4val;
|
|
};
|
|
|
|
template<class Function> class bndr_obj_1_3_4 :
|
|
public arity1opmf<Function>,
|
|
private arity4_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type> {
|
|
public:
|
|
explicit inline bndr_obj_1_3_4(Function::object_type& oi, const Function &f, Function::first_argument_type a1, Function::argument_3_type a3, Function::argument_4_type a4) :
|
|
arity1opmf<Function>(oi, reinterpret_cast<pmf1type>(f.pmf0)), arity4_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type>(f), arg1val(a1), arg3val(a3), arg4val(a4) {}
|
|
inline bndr_obj_1_3_4(const bndr_obj_1_3_4& bndri) :
|
|
arity1opmf<Function>(bndri.objval, reinterpret_cast<pmf1type>(bndri.pmf0)), arity4_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type>(bndri), arg1val(bndri.arg1val), arg3val(bndri.arg3val), arg4val(bndri.arg4val) {}
|
|
inline Function::result_type operator()(Function::second_argument_type a2) const {
|
|
pmf4type pmf = reinterpret_cast<pmf4type>(pmf0);
|
|
return (objval.*pmf)(arg1val, a2, arg3val, arg4val);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::argument_3_type arg3val;
|
|
Function::argument_4_type arg4val;
|
|
};
|
|
|
|
template<class Function> class bndr_obj_1_2_4 :
|
|
public arity1opmf<Function>,
|
|
private arity4_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type> {
|
|
public:
|
|
explicit inline bndr_obj_1_2_4(Function::object_type& oi, const Function &f, Function::first_argument_type a1, Function::second_argument_type a2, Function::argument_4_type a4) :
|
|
arity1opmf<Function>(oi, reinterpret_cast<pmf1type>(f.pmf0)), arity4_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type>(f), arg1val(a1), arg2val(a2), arg4val(a4) {}
|
|
inline bndr_obj_1_2_4(const bndr_obj_1_2_4& bndri) :
|
|
arity1opmf<Function>(bndri.objval, reinterpret_cast<pmf1type>(bndri.pmf0)), arity4_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type>(bndri), arg1val(bndri.arg1val), arg2val(bndri.arg2val), arg4val(bndri.arg4val) {}
|
|
inline Function::result_type operator()(Function::argument_3_type a3) const {
|
|
pmf4type pmf = reinterpret_cast<pmf4type>(pmf0);
|
|
return (objval.*pmf)(arg1val, arg2val, a3, arg4val);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::second_argument_type arg2val;
|
|
Function::argument_4_type arg4val;
|
|
};
|
|
|
|
|
|
|
|
// Template Classes for binding const obj&pmf Ref of arity 4 to arity 1
|
|
|
|
template<class Function> class bndr_const_obj_2_3_4 :
|
|
public arity1opmf_const<Function>,
|
|
private arity4_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type> {
|
|
public:
|
|
explicit inline bndr_const_obj_2_3_4(const Function::object_type& oi, const Function &f, Function::second_argument_type a2, Function::argument_3_type a3, Function::argument_4_type a4) :
|
|
arity1opmf_const<Function>(oi, reinterpret_cast<pmf1type>(f.pmf0)), arity4_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type>(f), arg2val(a2), arg3val(a3), arg4val(a4) {}
|
|
inline bndr_const_obj_2_3_4(const bndr_const_obj_2_3_4& bndri) :
|
|
arity1opmf_const<Function>(bndri.objval, reinterpret_cast<pmf1type>(bndri.pmf0)), arity4_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type>(bndri), arg2val(bndri.arg2val), arg3val(bndri.arg3val), arg4val(bndri.arg4val) {}
|
|
inline Function::result_type operator()(Function::first_argument_type a1) const {
|
|
pmf4type pmf = reinterpret_cast<pmf4type>(pmf0);
|
|
return (objval.*pmf)(a1, arg2val, arg3val, arg4val);
|
|
}
|
|
public:
|
|
Function::second_argument_type arg2val;
|
|
Function::argument_3_type arg3val;
|
|
Function::argument_4_type arg4val;
|
|
};
|
|
|
|
template<class Function> class bndr_const_obj_1_3_4 :
|
|
public arity1opmf_const<Function>,
|
|
private arity4_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type> {
|
|
public:
|
|
explicit inline bndr_const_obj_1_3_4(const Function::object_type& oi, const Function &f, Function::first_argument_type a1, Function::argument_3_type a3, Function::argument_4_type a4) :
|
|
arity1opmf_const<Function>(oi, reinterpret_cast<pmf1type>(f.pmf0)), arity4_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type>(f), arg1val(a1), arg3val(a3), arg4val(a4) {}
|
|
inline bndr_const_obj_1_3_4(const bndr_const_obj_1_3_4& bndri) :
|
|
arity1opmf_const<Function>(bndri.objval, reinterpret_cast<pmf1type>(bndri.pmf0)), arity4_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type>(bndri), arg1val(bndri.arg1val), arg3val(bndri.arg3val), arg4val(bndri.arg4val) {}
|
|
inline Function::result_type operator()(Function::second_argument_type a2) const {
|
|
pmf4type pmf = reinterpret_cast<pmf4type>(pmf0);
|
|
return (objval.*pmf)(arg1val, a2, arg3val, arg4val);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::argument_3_type arg3val;
|
|
Function::argument_4_type arg4val;
|
|
};
|
|
|
|
template<class Function> class bndr_const_obj_1_2_4 :
|
|
public arity1opmf_const<Function>,
|
|
private arity4_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type> {
|
|
public:
|
|
explicit inline bndr_const_obj_1_2_4(const Function::object_type& oi, const Function &f, Function::first_argument_type a1, Function::second_argument_type a2, Function::argument_4_type a4) :
|
|
arity1opmf_const<Function>(oi, reinterpret_cast<pmf1type>(f.pmf0)), arity4_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type>(f), arg1val(a1), arg2val(a2), arg4val(a4) {}
|
|
inline bndr_const_obj_1_2_4(const bndr_const_obj_1_2_4& bndri) :
|
|
arity1opmf_const<Function>(bndri.objval, reinterpret_cast<pmf1type>(bndri.pmf0)), arity4_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type>(bndri), arg1val(bndri.arg1val), arg2val(bndri.arg2val), arg4val(bndri.arg4val) {}
|
|
inline Function::result_type operator()(Function::argument_3_type a3) const {
|
|
pmf4type pmf = reinterpret_cast<pmf4type>(pmf0);
|
|
return (objval.*pmf)(arg1val, arg2val, a3, arg4val);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::second_argument_type arg2val;
|
|
Function::argument_4_type arg4val;
|
|
};
|
|
|
|
|
|
|
|
// Template Functions for binding arity 4 to arity 1
|
|
|
|
|
|
// Template Functions for binding pmf of arity 4 to arity 1
|
|
|
|
template<class Function, class A2,
|
|
class A3,
|
|
class A4> inline bndr_mf_2_3_4<Function>
|
|
bind_mf_2_3_4(const Function &f, A2 a2,
|
|
A3 a3,
|
|
A4 a4) {
|
|
return bndr_mf_2_3_4<Function>(f, Function::second_argument_type(a2), Function::argument_3_type(a3), Function::argument_4_type(a4));
|
|
};
|
|
|
|
template<class Function, class A1,
|
|
class A3,
|
|
class A4> inline bndr_mf_1_3_4<Function>
|
|
bind_mf_1_3_4(const Function &f, A1 a1,
|
|
A3 a3,
|
|
A4 a4) {
|
|
return bndr_mf_1_3_4<Function>(f, Function::first_argument_type(a1), Function::argument_3_type(a3), Function::argument_4_type(a4));
|
|
};
|
|
|
|
template<class Function, class A1,
|
|
class A2,
|
|
class A4> inline bndr_mf_1_2_4<Function>
|
|
bind_mf_1_2_4(const Function &f, A1 a1,
|
|
A2 a2,
|
|
A4 a4) {
|
|
return bndr_mf_1_2_4<Function>(f, Function::first_argument_type(a1), Function::second_argument_type(a2), Function::argument_4_type(a4));
|
|
};
|
|
|
|
|
|
|
|
// Template Functions for binding const pmf of arity 4 to arity 1
|
|
|
|
template<class Function, class A2,
|
|
class A3,
|
|
class A4> inline bndr_const_mf_2_3_4<Function>
|
|
bind_const_mf_2_3_4(const Function &f, A2 a2,
|
|
A3 a3,
|
|
A4 a4) {
|
|
return bndr_const_mf_2_3_4<Function>(f, Function::second_argument_type(a2), Function::argument_3_type(a3), Function::argument_4_type(a4));
|
|
};
|
|
|
|
template<class Function, class A1,
|
|
class A3,
|
|
class A4> inline bndr_const_mf_1_3_4<Function>
|
|
bind_const_mf_1_3_4(const Function &f, A1 a1,
|
|
A3 a3,
|
|
A4 a4) {
|
|
return bndr_const_mf_1_3_4<Function>(f, Function::first_argument_type(a1), Function::argument_3_type(a3), Function::argument_4_type(a4));
|
|
};
|
|
|
|
template<class Function, class A1,
|
|
class A2,
|
|
class A4> inline bndr_const_mf_1_2_4<Function>
|
|
bind_const_mf_1_2_4(const Function &f, A1 a1,
|
|
A2 a2,
|
|
A4 a4) {
|
|
return bndr_const_mf_1_2_4<Function>(f, Function::first_argument_type(a1), Function::second_argument_type(a2), Function::argument_4_type(a4));
|
|
};
|
|
|
|
|
|
|
|
// Template Functions for binding obj&pmf Ref of arity 4 to arity 1
|
|
|
|
template<class Function, class Object,
|
|
class A2,
|
|
class A3,
|
|
class A4> inline bndr_obj_2_3_4<Function>
|
|
bind_obj_2_3_4(Object& oi, const Function &f, A2 a2,
|
|
A3 a3,
|
|
A4 a4) {
|
|
return bndr_obj_2_3_4<Function>(static_cast<Function::object_type&>(oi), f, Function::second_argument_type(a2), Function::argument_3_type(a3), Function::argument_4_type(a4));
|
|
};
|
|
|
|
template<class Function, class Object,
|
|
class A1,
|
|
class A3,
|
|
class A4> inline bndr_obj_1_3_4<Function>
|
|
bind_obj_1_3_4(Object& oi, const Function &f, A1 a1,
|
|
A3 a3,
|
|
A4 a4) {
|
|
return bndr_obj_1_3_4<Function>(static_cast<Function::object_type&>(oi), f, Function::first_argument_type(a1), Function::argument_3_type(a3), Function::argument_4_type(a4));
|
|
};
|
|
|
|
template<class Function, class Object,
|
|
class A1,
|
|
class A2,
|
|
class A4> inline bndr_obj_1_2_4<Function>
|
|
bind_obj_1_2_4(Object& oi, const Function &f, A1 a1,
|
|
A2 a2,
|
|
A4 a4) {
|
|
return bndr_obj_1_2_4<Function>(static_cast<Function::object_type&>(oi), f, Function::first_argument_type(a1), Function::second_argument_type(a2), Function::argument_4_type(a4));
|
|
};
|
|
|
|
|
|
|
|
// Template Functions for binding const obj&pmf Ref of arity 4 to arity 1
|
|
|
|
template<class Function, const class Object,
|
|
class A2,
|
|
class A3,
|
|
class A4> inline bndr_const_obj_2_3_4<Function>
|
|
bind_const_obj_2_3_4(const Object& oi, const Function &f, A2 a2,
|
|
A3 a3,
|
|
A4 a4) {
|
|
return bndr_const_obj_2_3_4<Function>(static_cast<Function::object_type&>(oi), f, Function::second_argument_type(a2), Function::argument_3_type(a3), Function::argument_4_type(a4));
|
|
};
|
|
|
|
template<class Function, const class Object,
|
|
class A1,
|
|
class A3,
|
|
class A4> inline bndr_const_obj_1_3_4<Function>
|
|
bind_const_obj_1_3_4(const Object& oi, const Function &f, A1 a1,
|
|
A3 a3,
|
|
A4 a4) {
|
|
return bndr_const_obj_1_3_4<Function>(static_cast<Function::object_type&>(oi), f, Function::first_argument_type(a1), Function::argument_3_type(a3), Function::argument_4_type(a4));
|
|
};
|
|
|
|
template<class Function, const class Object,
|
|
class A1,
|
|
class A2,
|
|
class A4> inline bndr_const_obj_1_2_4<Function>
|
|
bind_const_obj_1_2_4(const Object& oi, const Function &f, A1 a1,
|
|
A2 a2,
|
|
A4 a4) {
|
|
return bndr_const_obj_1_2_4<Function>(static_cast<Function::object_type&>(oi), f, Function::first_argument_type(a1), Function::second_argument_type(a2), Function::argument_4_type(a4));
|
|
};
|
|
|
|
|
|
|
|
//
|
|
// binders for arity 5
|
|
//
|
|
|
|
|
|
// Template Classes for binding arity 5 to arity 1
|
|
|
|
|
|
// Template Classes for binding pmf of arity 5 to arity 1
|
|
|
|
template<class Function> class bndr_mf_2_3_4_5 :
|
|
public arity1pmf<Function::object_type, Function::first_argument_type, Function::result_type>,
|
|
private arity5_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type> {
|
|
public:
|
|
explicit inline bndr_mf_2_3_4_5(const Function &f, Function::second_argument_type a2, Function::argument_3_type a3, Function::argument_4_type a4, Function::argument_5_type a5) :
|
|
arity1pmf<Function::object_type, Function::first_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(f.pmf0)), arity5_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type>(f), arg2val(a2), arg3val(a3), arg4val(a4), arg5val(a5) {}
|
|
inline bndr_mf_2_3_4_5(const bndr_mf_2_3_4_5& bndri) :
|
|
arity1pmf<Function::object_type, Function::first_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(bndri.pmf0)), arity5_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type>(bndri), arg2val(bndri.arg2val), arg3val(bndri.arg3val), arg4val(bndri.arg4val), arg5val(bndri.arg5val) {}
|
|
inline virtual Function::result_type operator()(Function::object_type& o, Function::first_argument_type a1) const {
|
|
pmf5type pmf = reinterpret_cast<pmf5type>(pmf0);
|
|
return (o.*pmf)(a1, arg2val, arg3val, arg4val, arg5val);
|
|
}
|
|
public:
|
|
Function::second_argument_type arg2val;
|
|
Function::argument_3_type arg3val;
|
|
Function::argument_4_type arg4val;
|
|
Function::argument_5_type arg5val;
|
|
};
|
|
|
|
template<class Function> class bndr_mf_1_3_4_5 :
|
|
public arity1pmf<Function::object_type, Function::second_argument_type, Function::result_type>,
|
|
private arity5_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type> {
|
|
public:
|
|
explicit inline bndr_mf_1_3_4_5(const Function &f, Function::first_argument_type a1, Function::argument_3_type a3, Function::argument_4_type a4, Function::argument_5_type a5) :
|
|
arity1pmf<Function::object_type, Function::second_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(f.pmf0)), arity5_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type>(f), arg1val(a1), arg3val(a3), arg4val(a4), arg5val(a5) {}
|
|
inline bndr_mf_1_3_4_5(const bndr_mf_1_3_4_5& bndri) :
|
|
arity1pmf<Function::object_type, Function::second_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(bndri.pmf0)), arity5_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type>(bndri), arg1val(bndri.arg1val), arg3val(bndri.arg3val), arg4val(bndri.arg4val), arg5val(bndri.arg5val) {}
|
|
inline virtual Function::result_type operator()(Function::object_type& o, Function::second_argument_type a2) const {
|
|
pmf5type pmf = reinterpret_cast<pmf5type>(pmf0);
|
|
return (o.*pmf)(arg1val, a2, arg3val, arg4val, arg5val);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::argument_3_type arg3val;
|
|
Function::argument_4_type arg4val;
|
|
Function::argument_5_type arg5val;
|
|
};
|
|
|
|
template<class Function> class bndr_mf_1_2_4_5 :
|
|
public arity1pmf<Function::object_type, Function::argument_3_type, Function::result_type>,
|
|
private arity5_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type> {
|
|
public:
|
|
explicit inline bndr_mf_1_2_4_5(const Function &f, Function::first_argument_type a1, Function::second_argument_type a2, Function::argument_4_type a4, Function::argument_5_type a5) :
|
|
arity1pmf<Function::object_type, Function::argument_3_type, Function::result_type>(reinterpret_cast<pmf1type>(f.pmf0)), arity5_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type>(f), arg1val(a1), arg2val(a2), arg4val(a4), arg5val(a5) {}
|
|
inline bndr_mf_1_2_4_5(const bndr_mf_1_2_4_5& bndri) :
|
|
arity1pmf<Function::object_type, Function::argument_3_type, Function::result_type>(reinterpret_cast<pmf1type>(bndri.pmf0)), arity5_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type>(bndri), arg1val(bndri.arg1val), arg2val(bndri.arg2val), arg4val(bndri.arg4val), arg5val(bndri.arg5val) {}
|
|
inline virtual Function::result_type operator()(Function::object_type& o, Function::argument_3_type a3) const {
|
|
pmf5type pmf = reinterpret_cast<pmf5type>(pmf0);
|
|
return (o.*pmf)(arg1val, arg2val, a3, arg4val, arg5val);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::second_argument_type arg2val;
|
|
Function::argument_4_type arg4val;
|
|
Function::argument_5_type arg5val;
|
|
};
|
|
|
|
|
|
|
|
// Template Classes for binding const pmf of arity 5 to arity 1
|
|
|
|
template<class Function> class bndr_const_mf_2_3_4_5 :
|
|
public arity1pmf_const<Function::object_type, Function::first_argument_type, Function::result_type>,
|
|
private arity5_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type> {
|
|
public:
|
|
explicit inline bndr_const_mf_2_3_4_5(const Function &f, Function::second_argument_type a2, Function::argument_3_type a3, Function::argument_4_type a4, Function::argument_5_type a5) :
|
|
arity1pmf_const<Function::object_type, Function::first_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(f.pmf0)), arity5_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type>(f), arg2val(a2), arg3val(a3), arg4val(a4), arg5val(a5) {}
|
|
inline bndr_const_mf_2_3_4_5(const bndr_const_mf_2_3_4_5& bndri) :
|
|
arity1pmf_const<Function::object_type, Function::first_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(bndri.pmf0)), arity5_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type>(bndri), arg2val(bndri.arg2val), arg3val(bndri.arg3val), arg4val(bndri.arg4val), arg5val(bndri.arg5val) {}
|
|
inline virtual Function::result_type operator()(Function::object_type& o, Function::first_argument_type a1) const {
|
|
pmf5type pmf = reinterpret_cast<pmf5type>(pmf0);
|
|
return (o.*pmf)(a1, arg2val, arg3val, arg4val, arg5val);
|
|
}
|
|
public:
|
|
Function::second_argument_type arg2val;
|
|
Function::argument_3_type arg3val;
|
|
Function::argument_4_type arg4val;
|
|
Function::argument_5_type arg5val;
|
|
};
|
|
|
|
template<class Function> class bndr_const_mf_1_3_4_5 :
|
|
public arity1pmf_const<Function::object_type, Function::second_argument_type, Function::result_type>,
|
|
private arity5_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type> {
|
|
public:
|
|
explicit inline bndr_const_mf_1_3_4_5(const Function &f, Function::first_argument_type a1, Function::argument_3_type a3, Function::argument_4_type a4, Function::argument_5_type a5) :
|
|
arity1pmf_const<Function::object_type, Function::second_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(f.pmf0)), arity5_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type>(f), arg1val(a1), arg3val(a3), arg4val(a4), arg5val(a5) {}
|
|
inline bndr_const_mf_1_3_4_5(const bndr_const_mf_1_3_4_5& bndri) :
|
|
arity1pmf_const<Function::object_type, Function::second_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(bndri.pmf0)), arity5_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type>(bndri), arg1val(bndri.arg1val), arg3val(bndri.arg3val), arg4val(bndri.arg4val), arg5val(bndri.arg5val) {}
|
|
inline virtual Function::result_type operator()(Function::object_type& o, Function::second_argument_type a2) const {
|
|
pmf5type pmf = reinterpret_cast<pmf5type>(pmf0);
|
|
return (o.*pmf)(arg1val, a2, arg3val, arg4val, arg5val);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::argument_3_type arg3val;
|
|
Function::argument_4_type arg4val;
|
|
Function::argument_5_type arg5val;
|
|
};
|
|
|
|
template<class Function> class bndr_const_mf_1_2_4_5 :
|
|
public arity1pmf_const<Function::object_type, Function::argument_3_type, Function::result_type>,
|
|
private arity5_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type> {
|
|
public:
|
|
explicit inline bndr_const_mf_1_2_4_5(const Function &f, Function::first_argument_type a1, Function::second_argument_type a2, Function::argument_4_type a4, Function::argument_5_type a5) :
|
|
arity1pmf_const<Function::object_type, Function::argument_3_type, Function::result_type>(reinterpret_cast<pmf1type>(f.pmf0)), arity5_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type>(f), arg1val(a1), arg2val(a2), arg4val(a4), arg5val(a5) {}
|
|
inline bndr_const_mf_1_2_4_5(const bndr_const_mf_1_2_4_5& bndri) :
|
|
arity1pmf_const<Function::object_type, Function::argument_3_type, Function::result_type>(reinterpret_cast<pmf1type>(bndri.pmf0)), arity5_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type>(bndri), arg1val(bndri.arg1val), arg2val(bndri.arg2val), arg4val(bndri.arg4val), arg5val(bndri.arg5val) {}
|
|
inline virtual Function::result_type operator()(Function::object_type& o, Function::argument_3_type a3) const {
|
|
pmf5type pmf = reinterpret_cast<pmf5type>(pmf0);
|
|
return (o.*pmf)(arg1val, arg2val, a3, arg4val, arg5val);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::second_argument_type arg2val;
|
|
Function::argument_4_type arg4val;
|
|
Function::argument_5_type arg5val;
|
|
};
|
|
|
|
|
|
|
|
// Template Classes for binding obj&pmf Ref of arity 5 to arity 1
|
|
|
|
template<class Function> class bndr_obj_2_3_4_5 :
|
|
public arity1opmf<Function>,
|
|
private arity5_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type> {
|
|
public:
|
|
explicit inline bndr_obj_2_3_4_5(Function::object_type& oi, const Function &f, Function::second_argument_type a2, Function::argument_3_type a3, Function::argument_4_type a4, Function::argument_5_type a5) :
|
|
arity1opmf<Function>(oi, reinterpret_cast<pmf1type>(f.pmf0)), arity5_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type>(f), arg2val(a2), arg3val(a3), arg4val(a4), arg5val(a5) {}
|
|
inline bndr_obj_2_3_4_5(const bndr_obj_2_3_4_5& bndri) :
|
|
arity1opmf<Function>(bndri.objval, reinterpret_cast<pmf1type>(bndri.pmf0)), arity5_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type>(bndri), arg2val(bndri.arg2val), arg3val(bndri.arg3val), arg4val(bndri.arg4val), arg5val(bndri.arg5val) {}
|
|
inline Function::result_type operator()(Function::first_argument_type a1) const {
|
|
pmf5type pmf = reinterpret_cast<pmf5type>(pmf0);
|
|
return (objval.*pmf)(a1, arg2val, arg3val, arg4val, arg5val);
|
|
}
|
|
public:
|
|
Function::second_argument_type arg2val;
|
|
Function::argument_3_type arg3val;
|
|
Function::argument_4_type arg4val;
|
|
Function::argument_5_type arg5val;
|
|
};
|
|
|
|
template<class Function> class bndr_obj_1_3_4_5 :
|
|
public arity1opmf<Function>,
|
|
private arity5_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type> {
|
|
public:
|
|
explicit inline bndr_obj_1_3_4_5(Function::object_type& oi, const Function &f, Function::first_argument_type a1, Function::argument_3_type a3, Function::argument_4_type a4, Function::argument_5_type a5) :
|
|
arity1opmf<Function>(oi, reinterpret_cast<pmf1type>(f.pmf0)), arity5_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type>(f), arg1val(a1), arg3val(a3), arg4val(a4), arg5val(a5) {}
|
|
inline bndr_obj_1_3_4_5(const bndr_obj_1_3_4_5& bndri) :
|
|
arity1opmf<Function>(bndri.objval, reinterpret_cast<pmf1type>(bndri.pmf0)), arity5_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type>(bndri), arg1val(bndri.arg1val), arg3val(bndri.arg3val), arg4val(bndri.arg4val), arg5val(bndri.arg5val) {}
|
|
inline Function::result_type operator()(Function::second_argument_type a2) const {
|
|
pmf5type pmf = reinterpret_cast<pmf5type>(pmf0);
|
|
return (objval.*pmf)(arg1val, a2, arg3val, arg4val, arg5val);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::argument_3_type arg3val;
|
|
Function::argument_4_type arg4val;
|
|
Function::argument_5_type arg5val;
|
|
};
|
|
|
|
template<class Function> class bndr_obj_1_2_4_5 :
|
|
public arity1opmf<Function>,
|
|
private arity5_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type> {
|
|
public:
|
|
explicit inline bndr_obj_1_2_4_5(Function::object_type& oi, const Function &f, Function::first_argument_type a1, Function::second_argument_type a2, Function::argument_4_type a4, Function::argument_5_type a5) :
|
|
arity1opmf<Function>(oi, reinterpret_cast<pmf1type>(f.pmf0)), arity5_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type>(f), arg1val(a1), arg2val(a2), arg4val(a4), arg5val(a5) {}
|
|
inline bndr_obj_1_2_4_5(const bndr_obj_1_2_4_5& bndri) :
|
|
arity1opmf<Function>(bndri.objval, reinterpret_cast<pmf1type>(bndri.pmf0)), arity5_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type>(bndri), arg1val(bndri.arg1val), arg2val(bndri.arg2val), arg4val(bndri.arg4val), arg5val(bndri.arg5val) {}
|
|
inline Function::result_type operator()(Function::argument_3_type a3) const {
|
|
pmf5type pmf = reinterpret_cast<pmf5type>(pmf0);
|
|
return (objval.*pmf)(arg1val, arg2val, a3, arg4val, arg5val);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::second_argument_type arg2val;
|
|
Function::argument_4_type arg4val;
|
|
Function::argument_5_type arg5val;
|
|
};
|
|
|
|
|
|
|
|
// Template Classes for binding const obj&pmf Ref of arity 5 to arity 1
|
|
|
|
template<class Function> class bndr_const_obj_2_3_4_5 :
|
|
public arity1opmf_const<Function>,
|
|
private arity5_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type> {
|
|
public:
|
|
explicit inline bndr_const_obj_2_3_4_5(const Function::object_type& oi, const Function &f, Function::second_argument_type a2, Function::argument_3_type a3, Function::argument_4_type a4, Function::argument_5_type a5) :
|
|
arity1opmf_const<Function>(oi, reinterpret_cast<pmf1type>(f.pmf0)), arity5_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type>(f), arg2val(a2), arg3val(a3), arg4val(a4), arg5val(a5) {}
|
|
inline bndr_const_obj_2_3_4_5(const bndr_const_obj_2_3_4_5& bndri) :
|
|
arity1opmf_const<Function>(bndri.objval, reinterpret_cast<pmf1type>(bndri.pmf0)), arity5_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type>(bndri), arg2val(bndri.arg2val), arg3val(bndri.arg3val), arg4val(bndri.arg4val), arg5val(bndri.arg5val) {}
|
|
inline Function::result_type operator()(Function::first_argument_type a1) const {
|
|
pmf5type pmf = reinterpret_cast<pmf5type>(pmf0);
|
|
return (objval.*pmf)(a1, arg2val, arg3val, arg4val, arg5val);
|
|
}
|
|
public:
|
|
Function::second_argument_type arg2val;
|
|
Function::argument_3_type arg3val;
|
|
Function::argument_4_type arg4val;
|
|
Function::argument_5_type arg5val;
|
|
};
|
|
|
|
template<class Function> class bndr_const_obj_1_3_4_5 :
|
|
public arity1opmf_const<Function>,
|
|
private arity5_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type> {
|
|
public:
|
|
explicit inline bndr_const_obj_1_3_4_5(const Function::object_type& oi, const Function &f, Function::first_argument_type a1, Function::argument_3_type a3, Function::argument_4_type a4, Function::argument_5_type a5) :
|
|
arity1opmf_const<Function>(oi, reinterpret_cast<pmf1type>(f.pmf0)), arity5_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type>(f), arg1val(a1), arg3val(a3), arg4val(a4), arg5val(a5) {}
|
|
inline bndr_const_obj_1_3_4_5(const bndr_const_obj_1_3_4_5& bndri) :
|
|
arity1opmf_const<Function>(bndri.objval, reinterpret_cast<pmf1type>(bndri.pmf0)), arity5_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type>(bndri), arg1val(bndri.arg1val), arg3val(bndri.arg3val), arg4val(bndri.arg4val), arg5val(bndri.arg5val) {}
|
|
inline Function::result_type operator()(Function::second_argument_type a2) const {
|
|
pmf5type pmf = reinterpret_cast<pmf5type>(pmf0);
|
|
return (objval.*pmf)(arg1val, a2, arg3val, arg4val, arg5val);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::argument_3_type arg3val;
|
|
Function::argument_4_type arg4val;
|
|
Function::argument_5_type arg5val;
|
|
};
|
|
|
|
template<class Function> class bndr_const_obj_1_2_4_5 :
|
|
public arity1opmf_const<Function>,
|
|
private arity5_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type> {
|
|
public:
|
|
explicit inline bndr_const_obj_1_2_4_5(const Function::object_type& oi, const Function &f, Function::first_argument_type a1, Function::second_argument_type a2, Function::argument_4_type a4, Function::argument_5_type a5) :
|
|
arity1opmf_const<Function>(oi, reinterpret_cast<pmf1type>(f.pmf0)), arity5_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type>(f), arg1val(a1), arg2val(a2), arg4val(a4), arg5val(a5) {}
|
|
inline bndr_const_obj_1_2_4_5(const bndr_const_obj_1_2_4_5& bndri) :
|
|
arity1opmf_const<Function>(bndri.objval, reinterpret_cast<pmf1type>(bndri.pmf0)), arity5_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type>(bndri), arg1val(bndri.arg1val), arg2val(bndri.arg2val), arg4val(bndri.arg4val), arg5val(bndri.arg5val) {}
|
|
inline Function::result_type operator()(Function::argument_3_type a3) const {
|
|
pmf5type pmf = reinterpret_cast<pmf5type>(pmf0);
|
|
return (objval.*pmf)(arg1val, arg2val, a3, arg4val, arg5val);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::second_argument_type arg2val;
|
|
Function::argument_4_type arg4val;
|
|
Function::argument_5_type arg5val;
|
|
};
|
|
|
|
|
|
|
|
// Template Functions for binding arity 5 to arity 1
|
|
|
|
|
|
// Template Functions for binding pmf of arity 5 to arity 1
|
|
|
|
template<class Function, class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5> inline bndr_mf_2_3_4_5<Function>
|
|
bind_mf_2_3_4_5(const Function &f, A2 a2,
|
|
A3 a3,
|
|
A4 a4,
|
|
A5 a5) {
|
|
return bndr_mf_2_3_4_5<Function>(f, Function::second_argument_type(a2), Function::argument_3_type(a3), Function::argument_4_type(a4), Function::argument_5_type(a5));
|
|
};
|
|
|
|
template<class Function, class A1,
|
|
class A3,
|
|
class A4,
|
|
class A5> inline bndr_mf_1_3_4_5<Function>
|
|
bind_mf_1_3_4_5(const Function &f, A1 a1,
|
|
A3 a3,
|
|
A4 a4,
|
|
A5 a5) {
|
|
return bndr_mf_1_3_4_5<Function>(f, Function::first_argument_type(a1), Function::argument_3_type(a3), Function::argument_4_type(a4), Function::argument_5_type(a5));
|
|
};
|
|
|
|
template<class Function, class A1,
|
|
class A2,
|
|
class A4,
|
|
class A5> inline bndr_mf_1_2_4_5<Function>
|
|
bind_mf_1_2_4_5(const Function &f, A1 a1,
|
|
A2 a2,
|
|
A4 a4,
|
|
A5 a5) {
|
|
return bndr_mf_1_2_4_5<Function>(f, Function::first_argument_type(a1), Function::second_argument_type(a2), Function::argument_4_type(a4), Function::argument_5_type(a5));
|
|
};
|
|
|
|
|
|
|
|
// Template Functions for binding const pmf of arity 5 to arity 1
|
|
|
|
template<class Function, class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5> inline bndr_const_mf_2_3_4_5<Function>
|
|
bind_const_mf_2_3_4_5(const Function &f, A2 a2,
|
|
A3 a3,
|
|
A4 a4,
|
|
A5 a5) {
|
|
return bndr_const_mf_2_3_4_5<Function>(f, Function::second_argument_type(a2), Function::argument_3_type(a3), Function::argument_4_type(a4), Function::argument_5_type(a5));
|
|
};
|
|
|
|
template<class Function, class A1,
|
|
class A3,
|
|
class A4,
|
|
class A5> inline bndr_const_mf_1_3_4_5<Function>
|
|
bind_const_mf_1_3_4_5(const Function &f, A1 a1,
|
|
A3 a3,
|
|
A4 a4,
|
|
A5 a5) {
|
|
return bndr_const_mf_1_3_4_5<Function>(f, Function::first_argument_type(a1), Function::argument_3_type(a3), Function::argument_4_type(a4), Function::argument_5_type(a5));
|
|
};
|
|
|
|
template<class Function, class A1,
|
|
class A2,
|
|
class A4,
|
|
class A5> inline bndr_const_mf_1_2_4_5<Function>
|
|
bind_const_mf_1_2_4_5(const Function &f, A1 a1,
|
|
A2 a2,
|
|
A4 a4,
|
|
A5 a5) {
|
|
return bndr_const_mf_1_2_4_5<Function>(f, Function::first_argument_type(a1), Function::second_argument_type(a2), Function::argument_4_type(a4), Function::argument_5_type(a5));
|
|
};
|
|
|
|
|
|
|
|
// Template Functions for binding obj&pmf Ref of arity 5 to arity 1
|
|
|
|
template<class Function, class Object,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5> inline bndr_obj_2_3_4_5<Function>
|
|
bind_obj_2_3_4_5(Object& oi, const Function &f, A2 a2,
|
|
A3 a3,
|
|
A4 a4,
|
|
A5 a5) {
|
|
return bndr_obj_2_3_4_5<Function>(static_cast<Function::object_type&>(oi), f, Function::second_argument_type(a2), Function::argument_3_type(a3), Function::argument_4_type(a4), Function::argument_5_type(a5));
|
|
};
|
|
|
|
template<class Function, class Object,
|
|
class A1,
|
|
class A3,
|
|
class A4,
|
|
class A5> inline bndr_obj_1_3_4_5<Function>
|
|
bind_obj_1_3_4_5(Object& oi, const Function &f, A1 a1,
|
|
A3 a3,
|
|
A4 a4,
|
|
A5 a5) {
|
|
return bndr_obj_1_3_4_5<Function>(static_cast<Function::object_type&>(oi), f, Function::first_argument_type(a1), Function::argument_3_type(a3), Function::argument_4_type(a4), Function::argument_5_type(a5));
|
|
};
|
|
|
|
template<class Function, class Object,
|
|
class A1,
|
|
class A2,
|
|
class A4,
|
|
class A5> inline bndr_obj_1_2_4_5<Function>
|
|
bind_obj_1_2_4_5(Object& oi, const Function &f, A1 a1,
|
|
A2 a2,
|
|
A4 a4,
|
|
A5 a5) {
|
|
return bndr_obj_1_2_4_5<Function>(static_cast<Function::object_type&>(oi), f, Function::first_argument_type(a1), Function::second_argument_type(a2), Function::argument_4_type(a4), Function::argument_5_type(a5));
|
|
};
|
|
|
|
|
|
|
|
// Template Functions for binding const obj&pmf Ref of arity 5 to arity 1
|
|
|
|
template<class Function, const class Object,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5> inline bndr_const_obj_2_3_4_5<Function>
|
|
bind_const_obj_2_3_4_5(const Object& oi, const Function &f, A2 a2,
|
|
A3 a3,
|
|
A4 a4,
|
|
A5 a5) {
|
|
return bndr_const_obj_2_3_4_5<Function>(static_cast<Function::object_type&>(oi), f, Function::second_argument_type(a2), Function::argument_3_type(a3), Function::argument_4_type(a4), Function::argument_5_type(a5));
|
|
};
|
|
|
|
template<class Function, const class Object,
|
|
class A1,
|
|
class A3,
|
|
class A4,
|
|
class A5> inline bndr_const_obj_1_3_4_5<Function>
|
|
bind_const_obj_1_3_4_5(const Object& oi, const Function &f, A1 a1,
|
|
A3 a3,
|
|
A4 a4,
|
|
A5 a5) {
|
|
return bndr_const_obj_1_3_4_5<Function>(static_cast<Function::object_type&>(oi), f, Function::first_argument_type(a1), Function::argument_3_type(a3), Function::argument_4_type(a4), Function::argument_5_type(a5));
|
|
};
|
|
|
|
template<class Function, const class Object,
|
|
class A1,
|
|
class A2,
|
|
class A4,
|
|
class A5> inline bndr_const_obj_1_2_4_5<Function>
|
|
bind_const_obj_1_2_4_5(const Object& oi, const Function &f, A1 a1,
|
|
A2 a2,
|
|
A4 a4,
|
|
A5 a5) {
|
|
return bndr_const_obj_1_2_4_5<Function>(static_cast<Function::object_type&>(oi), f, Function::first_argument_type(a1), Function::second_argument_type(a2), Function::argument_4_type(a4), Function::argument_5_type(a5));
|
|
};
|
|
|
|
|
|
|
|
//
|
|
// binders for arity 6
|
|
//
|
|
|
|
|
|
// Template Classes for binding arity 6 to arity 1
|
|
|
|
|
|
// Template Classes for binding pmf of arity 6 to arity 1
|
|
|
|
template<class Function> class bndr_mf_2_3_4_5_6 :
|
|
public arity1pmf<Function::object_type, Function::first_argument_type, Function::result_type>,
|
|
private arity6_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type> {
|
|
public:
|
|
explicit inline bndr_mf_2_3_4_5_6(const Function &f, Function::second_argument_type a2, Function::argument_3_type a3, Function::argument_4_type a4, Function::argument_5_type a5, Function::argument_6_type a6) :
|
|
arity1pmf<Function::object_type, Function::first_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(f.pmf0)), arity6_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type>(f), arg2val(a2), arg3val(a3), arg4val(a4), arg5val(a5), arg6val(a6) {}
|
|
inline bndr_mf_2_3_4_5_6(const bndr_mf_2_3_4_5_6& bndri) :
|
|
arity1pmf<Function::object_type, Function::first_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(bndri.pmf0)), arity6_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type>(bndri), arg2val(bndri.arg2val), arg3val(bndri.arg3val), arg4val(bndri.arg4val), arg5val(bndri.arg5val), arg6val(bndri.arg6val) {}
|
|
inline virtual Function::result_type operator()(Function::object_type& o, Function::first_argument_type a1) const {
|
|
pmf6type pmf = reinterpret_cast<pmf6type>(pmf0);
|
|
return (o.*pmf)(a1, arg2val, arg3val, arg4val, arg5val, arg6val);
|
|
}
|
|
public:
|
|
Function::second_argument_type arg2val;
|
|
Function::argument_3_type arg3val;
|
|
Function::argument_4_type arg4val;
|
|
Function::argument_5_type arg5val;
|
|
Function::argument_6_type arg6val;
|
|
};
|
|
|
|
template<class Function> class bndr_mf_1_3_4_5_6 :
|
|
public arity1pmf<Function::object_type, Function::second_argument_type, Function::result_type>,
|
|
private arity6_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type> {
|
|
public:
|
|
explicit inline bndr_mf_1_3_4_5_6(const Function &f, Function::first_argument_type a1, Function::argument_3_type a3, Function::argument_4_type a4, Function::argument_5_type a5, Function::argument_6_type a6) :
|
|
arity1pmf<Function::object_type, Function::second_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(f.pmf0)), arity6_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type>(f), arg1val(a1), arg3val(a3), arg4val(a4), arg5val(a5), arg6val(a6) {}
|
|
inline bndr_mf_1_3_4_5_6(const bndr_mf_1_3_4_5_6& bndri) :
|
|
arity1pmf<Function::object_type, Function::second_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(bndri.pmf0)), arity6_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type>(bndri), arg1val(bndri.arg1val), arg3val(bndri.arg3val), arg4val(bndri.arg4val), arg5val(bndri.arg5val), arg6val(bndri.arg6val) {}
|
|
inline virtual Function::result_type operator()(Function::object_type& o, Function::second_argument_type a2) const {
|
|
pmf6type pmf = reinterpret_cast<pmf6type>(pmf0);
|
|
return (o.*pmf)(arg1val, a2, arg3val, arg4val, arg5val, arg6val);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::argument_3_type arg3val;
|
|
Function::argument_4_type arg4val;
|
|
Function::argument_5_type arg5val;
|
|
Function::argument_6_type arg6val;
|
|
};
|
|
|
|
template<class Function> class bndr_mf_1_2_4_5_6 :
|
|
public arity1pmf<Function::object_type, Function::argument_3_type, Function::result_type>,
|
|
private arity6_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type> {
|
|
public:
|
|
explicit inline bndr_mf_1_2_4_5_6(const Function &f, Function::first_argument_type a1, Function::second_argument_type a2, Function::argument_4_type a4, Function::argument_5_type a5, Function::argument_6_type a6) :
|
|
arity1pmf<Function::object_type, Function::argument_3_type, Function::result_type>(reinterpret_cast<pmf1type>(f.pmf0)), arity6_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type>(f), arg1val(a1), arg2val(a2), arg4val(a4), arg5val(a5), arg6val(a6) {}
|
|
inline bndr_mf_1_2_4_5_6(const bndr_mf_1_2_4_5_6& bndri) :
|
|
arity1pmf<Function::object_type, Function::argument_3_type, Function::result_type>(reinterpret_cast<pmf1type>(bndri.pmf0)), arity6_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type>(bndri), arg1val(bndri.arg1val), arg2val(bndri.arg2val), arg4val(bndri.arg4val), arg5val(bndri.arg5val), arg6val(bndri.arg6val) {}
|
|
inline virtual Function::result_type operator()(Function::object_type& o, Function::argument_3_type a3) const {
|
|
pmf6type pmf = reinterpret_cast<pmf6type>(pmf0);
|
|
return (o.*pmf)(arg1val, arg2val, a3, arg4val, arg5val, arg6val);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::second_argument_type arg2val;
|
|
Function::argument_4_type arg4val;
|
|
Function::argument_5_type arg5val;
|
|
Function::argument_6_type arg6val;
|
|
};
|
|
|
|
|
|
|
|
// Template Classes for binding const pmf of arity 6 to arity 1
|
|
|
|
template<class Function> class bndr_const_mf_2_3_4_5_6 :
|
|
public arity1pmf_const<Function::object_type, Function::first_argument_type, Function::result_type>,
|
|
private arity6_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type> {
|
|
public:
|
|
explicit inline bndr_const_mf_2_3_4_5_6(const Function &f, Function::second_argument_type a2, Function::argument_3_type a3, Function::argument_4_type a4, Function::argument_5_type a5, Function::argument_6_type a6) :
|
|
arity1pmf_const<Function::object_type, Function::first_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(f.pmf0)), arity6_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type>(f), arg2val(a2), arg3val(a3), arg4val(a4), arg5val(a5), arg6val(a6) {}
|
|
inline bndr_const_mf_2_3_4_5_6(const bndr_const_mf_2_3_4_5_6& bndri) :
|
|
arity1pmf_const<Function::object_type, Function::first_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(bndri.pmf0)), arity6_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type>(bndri), arg2val(bndri.arg2val), arg3val(bndri.arg3val), arg4val(bndri.arg4val), arg5val(bndri.arg5val), arg6val(bndri.arg6val) {}
|
|
inline virtual Function::result_type operator()(Function::object_type& o, Function::first_argument_type a1) const {
|
|
pmf6type pmf = reinterpret_cast<pmf6type>(pmf0);
|
|
return (o.*pmf)(a1, arg2val, arg3val, arg4val, arg5val, arg6val);
|
|
}
|
|
public:
|
|
Function::second_argument_type arg2val;
|
|
Function::argument_3_type arg3val;
|
|
Function::argument_4_type arg4val;
|
|
Function::argument_5_type arg5val;
|
|
Function::argument_6_type arg6val;
|
|
};
|
|
|
|
template<class Function> class bndr_const_mf_1_3_4_5_6 :
|
|
public arity1pmf_const<Function::object_type, Function::second_argument_type, Function::result_type>,
|
|
private arity6_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type> {
|
|
public:
|
|
explicit inline bndr_const_mf_1_3_4_5_6(const Function &f, Function::first_argument_type a1, Function::argument_3_type a3, Function::argument_4_type a4, Function::argument_5_type a5, Function::argument_6_type a6) :
|
|
arity1pmf_const<Function::object_type, Function::second_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(f.pmf0)), arity6_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type>(f), arg1val(a1), arg3val(a3), arg4val(a4), arg5val(a5), arg6val(a6) {}
|
|
inline bndr_const_mf_1_3_4_5_6(const bndr_const_mf_1_3_4_5_6& bndri) :
|
|
arity1pmf_const<Function::object_type, Function::second_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(bndri.pmf0)), arity6_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type>(bndri), arg1val(bndri.arg1val), arg3val(bndri.arg3val), arg4val(bndri.arg4val), arg5val(bndri.arg5val), arg6val(bndri.arg6val) {}
|
|
inline virtual Function::result_type operator()(Function::object_type& o, Function::second_argument_type a2) const {
|
|
pmf6type pmf = reinterpret_cast<pmf6type>(pmf0);
|
|
return (o.*pmf)(arg1val, a2, arg3val, arg4val, arg5val, arg6val);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::argument_3_type arg3val;
|
|
Function::argument_4_type arg4val;
|
|
Function::argument_5_type arg5val;
|
|
Function::argument_6_type arg6val;
|
|
};
|
|
|
|
template<class Function> class bndr_const_mf_1_2_4_5_6 :
|
|
public arity1pmf_const<Function::object_type, Function::argument_3_type, Function::result_type>,
|
|
private arity6_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type> {
|
|
public:
|
|
explicit inline bndr_const_mf_1_2_4_5_6(const Function &f, Function::first_argument_type a1, Function::second_argument_type a2, Function::argument_4_type a4, Function::argument_5_type a5, Function::argument_6_type a6) :
|
|
arity1pmf_const<Function::object_type, Function::argument_3_type, Function::result_type>(reinterpret_cast<pmf1type>(f.pmf0)), arity6_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type>(f), arg1val(a1), arg2val(a2), arg4val(a4), arg5val(a5), arg6val(a6) {}
|
|
inline bndr_const_mf_1_2_4_5_6(const bndr_const_mf_1_2_4_5_6& bndri) :
|
|
arity1pmf_const<Function::object_type, Function::argument_3_type, Function::result_type>(reinterpret_cast<pmf1type>(bndri.pmf0)), arity6_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type>(bndri), arg1val(bndri.arg1val), arg2val(bndri.arg2val), arg4val(bndri.arg4val), arg5val(bndri.arg5val), arg6val(bndri.arg6val) {}
|
|
inline virtual Function::result_type operator()(Function::object_type& o, Function::argument_3_type a3) const {
|
|
pmf6type pmf = reinterpret_cast<pmf6type>(pmf0);
|
|
return (o.*pmf)(arg1val, arg2val, a3, arg4val, arg5val, arg6val);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::second_argument_type arg2val;
|
|
Function::argument_4_type arg4val;
|
|
Function::argument_5_type arg5val;
|
|
Function::argument_6_type arg6val;
|
|
};
|
|
|
|
|
|
|
|
// Template Classes for binding obj&pmf Ref of arity 6 to arity 1
|
|
|
|
template<class Function> class bndr_obj_2_3_4_5_6 :
|
|
public arity1opmf<Function>,
|
|
private arity6_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type> {
|
|
public:
|
|
explicit inline bndr_obj_2_3_4_5_6(Function::object_type& oi, const Function &f, Function::second_argument_type a2, Function::argument_3_type a3, Function::argument_4_type a4, Function::argument_5_type a5, Function::argument_6_type a6) :
|
|
arity1opmf<Function>(oi, reinterpret_cast<pmf1type>(f.pmf0)), arity6_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type>(f), arg2val(a2), arg3val(a3), arg4val(a4), arg5val(a5), arg6val(a6) {}
|
|
inline bndr_obj_2_3_4_5_6(const bndr_obj_2_3_4_5_6& bndri) :
|
|
arity1opmf<Function>(bndri.objval, reinterpret_cast<pmf1type>(bndri.pmf0)), arity6_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type>(bndri), arg2val(bndri.arg2val), arg3val(bndri.arg3val), arg4val(bndri.arg4val), arg5val(bndri.arg5val), arg6val(bndri.arg6val) {}
|
|
inline Function::result_type operator()(Function::first_argument_type a1) const {
|
|
pmf6type pmf = reinterpret_cast<pmf6type>(pmf0);
|
|
return (objval.*pmf)(a1, arg2val, arg3val, arg4val, arg5val, arg6val);
|
|
}
|
|
public:
|
|
Function::second_argument_type arg2val;
|
|
Function::argument_3_type arg3val;
|
|
Function::argument_4_type arg4val;
|
|
Function::argument_5_type arg5val;
|
|
Function::argument_6_type arg6val;
|
|
};
|
|
|
|
template<class Function> class bndr_obj_1_3_4_5_6 :
|
|
public arity1opmf<Function>,
|
|
private arity6_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type> {
|
|
public:
|
|
explicit inline bndr_obj_1_3_4_5_6(Function::object_type& oi, const Function &f, Function::first_argument_type a1, Function::argument_3_type a3, Function::argument_4_type a4, Function::argument_5_type a5, Function::argument_6_type a6) :
|
|
arity1opmf<Function>(oi, reinterpret_cast<pmf1type>(f.pmf0)), arity6_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type>(f), arg1val(a1), arg3val(a3), arg4val(a4), arg5val(a5), arg6val(a6) {}
|
|
inline bndr_obj_1_3_4_5_6(const bndr_obj_1_3_4_5_6& bndri) :
|
|
arity1opmf<Function>(bndri.objval, reinterpret_cast<pmf1type>(bndri.pmf0)), arity6_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type>(bndri), arg1val(bndri.arg1val), arg3val(bndri.arg3val), arg4val(bndri.arg4val), arg5val(bndri.arg5val), arg6val(bndri.arg6val) {}
|
|
inline Function::result_type operator()(Function::second_argument_type a2) const {
|
|
pmf6type pmf = reinterpret_cast<pmf6type>(pmf0);
|
|
return (objval.*pmf)(arg1val, a2, arg3val, arg4val, arg5val, arg6val);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::argument_3_type arg3val;
|
|
Function::argument_4_type arg4val;
|
|
Function::argument_5_type arg5val;
|
|
Function::argument_6_type arg6val;
|
|
};
|
|
|
|
template<class Function> class bndr_obj_1_2_4_5_6 :
|
|
public arity1opmf<Function>,
|
|
private arity6_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type> {
|
|
public:
|
|
explicit inline bndr_obj_1_2_4_5_6(Function::object_type& oi, const Function &f, Function::first_argument_type a1, Function::second_argument_type a2, Function::argument_4_type a4, Function::argument_5_type a5, Function::argument_6_type a6) :
|
|
arity1opmf<Function>(oi, reinterpret_cast<pmf1type>(f.pmf0)), arity6_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type>(f), arg1val(a1), arg2val(a2), arg4val(a4), arg5val(a5), arg6val(a6) {}
|
|
inline bndr_obj_1_2_4_5_6(const bndr_obj_1_2_4_5_6& bndri) :
|
|
arity1opmf<Function>(bndri.objval, reinterpret_cast<pmf1type>(bndri.pmf0)), arity6_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type>(bndri), arg1val(bndri.arg1val), arg2val(bndri.arg2val), arg4val(bndri.arg4val), arg5val(bndri.arg5val), arg6val(bndri.arg6val) {}
|
|
inline Function::result_type operator()(Function::argument_3_type a3) const {
|
|
pmf6type pmf = reinterpret_cast<pmf6type>(pmf0);
|
|
return (objval.*pmf)(arg1val, arg2val, a3, arg4val, arg5val, arg6val);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::second_argument_type arg2val;
|
|
Function::argument_4_type arg4val;
|
|
Function::argument_5_type arg5val;
|
|
Function::argument_6_type arg6val;
|
|
};
|
|
|
|
|
|
|
|
// Template Classes for binding const obj&pmf Ref of arity 6 to arity 1
|
|
|
|
template<class Function> class bndr_const_obj_2_3_4_5_6 :
|
|
public arity1opmf_const<Function>,
|
|
private arity6_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type> {
|
|
public:
|
|
explicit inline bndr_const_obj_2_3_4_5_6(const Function::object_type& oi, const Function &f, Function::second_argument_type a2, Function::argument_3_type a3, Function::argument_4_type a4, Function::argument_5_type a5, Function::argument_6_type a6) :
|
|
arity1opmf_const<Function>(oi, reinterpret_cast<pmf1type>(f.pmf0)), arity6_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type>(f), arg2val(a2), arg3val(a3), arg4val(a4), arg5val(a5), arg6val(a6) {}
|
|
inline bndr_const_obj_2_3_4_5_6(const bndr_const_obj_2_3_4_5_6& bndri) :
|
|
arity1opmf_const<Function>(bndri.objval, reinterpret_cast<pmf1type>(bndri.pmf0)), arity6_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type>(bndri), arg2val(bndri.arg2val), arg3val(bndri.arg3val), arg4val(bndri.arg4val), arg5val(bndri.arg5val), arg6val(bndri.arg6val) {}
|
|
inline Function::result_type operator()(Function::first_argument_type a1) const {
|
|
pmf6type pmf = reinterpret_cast<pmf6type>(pmf0);
|
|
return (objval.*pmf)(a1, arg2val, arg3val, arg4val, arg5val, arg6val);
|
|
}
|
|
public:
|
|
Function::second_argument_type arg2val;
|
|
Function::argument_3_type arg3val;
|
|
Function::argument_4_type arg4val;
|
|
Function::argument_5_type arg5val;
|
|
Function::argument_6_type arg6val;
|
|
};
|
|
|
|
template<class Function> class bndr_const_obj_1_3_4_5_6 :
|
|
public arity1opmf_const<Function>,
|
|
private arity6_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type> {
|
|
public:
|
|
explicit inline bndr_const_obj_1_3_4_5_6(const Function::object_type& oi, const Function &f, Function::first_argument_type a1, Function::argument_3_type a3, Function::argument_4_type a4, Function::argument_5_type a5, Function::argument_6_type a6) :
|
|
arity1opmf_const<Function>(oi, reinterpret_cast<pmf1type>(f.pmf0)), arity6_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type>(f), arg1val(a1), arg3val(a3), arg4val(a4), arg5val(a5), arg6val(a6) {}
|
|
inline bndr_const_obj_1_3_4_5_6(const bndr_const_obj_1_3_4_5_6& bndri) :
|
|
arity1opmf_const<Function>(bndri.objval, reinterpret_cast<pmf1type>(bndri.pmf0)), arity6_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type>(bndri), arg1val(bndri.arg1val), arg3val(bndri.arg3val), arg4val(bndri.arg4val), arg5val(bndri.arg5val), arg6val(bndri.arg6val) {}
|
|
inline Function::result_type operator()(Function::second_argument_type a2) const {
|
|
pmf6type pmf = reinterpret_cast<pmf6type>(pmf0);
|
|
return (objval.*pmf)(arg1val, a2, arg3val, arg4val, arg5val, arg6val);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::argument_3_type arg3val;
|
|
Function::argument_4_type arg4val;
|
|
Function::argument_5_type arg5val;
|
|
Function::argument_6_type arg6val;
|
|
};
|
|
|
|
template<class Function> class bndr_const_obj_1_2_4_5_6 :
|
|
public arity1opmf_const<Function>,
|
|
private arity6_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type> {
|
|
public:
|
|
explicit inline bndr_const_obj_1_2_4_5_6(const Function::object_type& oi, const Function &f, Function::first_argument_type a1, Function::second_argument_type a2, Function::argument_4_type a4, Function::argument_5_type a5, Function::argument_6_type a6) :
|
|
arity1opmf_const<Function>(oi, reinterpret_cast<pmf1type>(f.pmf0)), arity6_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type>(f), arg1val(a1), arg2val(a2), arg4val(a4), arg5val(a5), arg6val(a6) {}
|
|
inline bndr_const_obj_1_2_4_5_6(const bndr_const_obj_1_2_4_5_6& bndri) :
|
|
arity1opmf_const<Function>(bndri.objval, reinterpret_cast<pmf1type>(bndri.pmf0)), arity6_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type>(bndri), arg1val(bndri.arg1val), arg2val(bndri.arg2val), arg4val(bndri.arg4val), arg5val(bndri.arg5val), arg6val(bndri.arg6val) {}
|
|
inline Function::result_type operator()(Function::argument_3_type a3) const {
|
|
pmf6type pmf = reinterpret_cast<pmf6type>(pmf0);
|
|
return (objval.*pmf)(arg1val, arg2val, a3, arg4val, arg5val, arg6val);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::second_argument_type arg2val;
|
|
Function::argument_4_type arg4val;
|
|
Function::argument_5_type arg5val;
|
|
Function::argument_6_type arg6val;
|
|
};
|
|
|
|
|
|
|
|
// Template Functions for binding arity 6 to arity 1
|
|
|
|
|
|
// Template Functions for binding pmf of arity 6 to arity 1
|
|
|
|
template<class Function, class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6> inline bndr_mf_2_3_4_5_6<Function>
|
|
bind_mf_2_3_4_5_6(const Function &f, A2 a2,
|
|
A3 a3,
|
|
A4 a4,
|
|
A5 a5,
|
|
A6 a6) {
|
|
return bndr_mf_2_3_4_5_6<Function>(f, Function::second_argument_type(a2), Function::argument_3_type(a3), Function::argument_4_type(a4), Function::argument_5_type(a5), Function::argument_6_type(a6));
|
|
};
|
|
|
|
template<class Function, class A1,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6> inline bndr_mf_1_3_4_5_6<Function>
|
|
bind_mf_1_3_4_5_6(const Function &f, A1 a1,
|
|
A3 a3,
|
|
A4 a4,
|
|
A5 a5,
|
|
A6 a6) {
|
|
return bndr_mf_1_3_4_5_6<Function>(f, Function::first_argument_type(a1), Function::argument_3_type(a3), Function::argument_4_type(a4), Function::argument_5_type(a5), Function::argument_6_type(a6));
|
|
};
|
|
|
|
template<class Function, class A1,
|
|
class A2,
|
|
class A4,
|
|
class A5,
|
|
class A6> inline bndr_mf_1_2_4_5_6<Function>
|
|
bind_mf_1_2_4_5_6(const Function &f, A1 a1,
|
|
A2 a2,
|
|
A4 a4,
|
|
A5 a5,
|
|
A6 a6) {
|
|
return bndr_mf_1_2_4_5_6<Function>(f, Function::first_argument_type(a1), Function::second_argument_type(a2), Function::argument_4_type(a4), Function::argument_5_type(a5), Function::argument_6_type(a6));
|
|
};
|
|
|
|
|
|
|
|
// Template Functions for binding const pmf of arity 6 to arity 1
|
|
|
|
template<class Function, class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6> inline bndr_const_mf_2_3_4_5_6<Function>
|
|
bind_const_mf_2_3_4_5_6(const Function &f, A2 a2,
|
|
A3 a3,
|
|
A4 a4,
|
|
A5 a5,
|
|
A6 a6) {
|
|
return bndr_const_mf_2_3_4_5_6<Function>(f, Function::second_argument_type(a2), Function::argument_3_type(a3), Function::argument_4_type(a4), Function::argument_5_type(a5), Function::argument_6_type(a6));
|
|
};
|
|
|
|
template<class Function, class A1,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6> inline bndr_const_mf_1_3_4_5_6<Function>
|
|
bind_const_mf_1_3_4_5_6(const Function &f, A1 a1,
|
|
A3 a3,
|
|
A4 a4,
|
|
A5 a5,
|
|
A6 a6) {
|
|
return bndr_const_mf_1_3_4_5_6<Function>(f, Function::first_argument_type(a1), Function::argument_3_type(a3), Function::argument_4_type(a4), Function::argument_5_type(a5), Function::argument_6_type(a6));
|
|
};
|
|
|
|
template<class Function, class A1,
|
|
class A2,
|
|
class A4,
|
|
class A5,
|
|
class A6> inline bndr_const_mf_1_2_4_5_6<Function>
|
|
bind_const_mf_1_2_4_5_6(const Function &f, A1 a1,
|
|
A2 a2,
|
|
A4 a4,
|
|
A5 a5,
|
|
A6 a6) {
|
|
return bndr_const_mf_1_2_4_5_6<Function>(f, Function::first_argument_type(a1), Function::second_argument_type(a2), Function::argument_4_type(a4), Function::argument_5_type(a5), Function::argument_6_type(a6));
|
|
};
|
|
|
|
|
|
|
|
// Template Functions for binding obj&pmf Ref of arity 6 to arity 1
|
|
|
|
template<class Function, class Object,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6> inline bndr_obj_2_3_4_5_6<Function>
|
|
bind_obj_2_3_4_5_6(Object& oi, const Function &f, A2 a2,
|
|
A3 a3,
|
|
A4 a4,
|
|
A5 a5,
|
|
A6 a6) {
|
|
return bndr_obj_2_3_4_5_6<Function>(static_cast<Function::object_type&>(oi), f, Function::second_argument_type(a2), Function::argument_3_type(a3), Function::argument_4_type(a4), Function::argument_5_type(a5), Function::argument_6_type(a6));
|
|
};
|
|
|
|
template<class Function, class Object,
|
|
class A1,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6> inline bndr_obj_1_3_4_5_6<Function>
|
|
bind_obj_1_3_4_5_6(Object& oi, const Function &f, A1 a1,
|
|
A3 a3,
|
|
A4 a4,
|
|
A5 a5,
|
|
A6 a6) {
|
|
return bndr_obj_1_3_4_5_6<Function>(static_cast<Function::object_type&>(oi), f, Function::first_argument_type(a1), Function::argument_3_type(a3), Function::argument_4_type(a4), Function::argument_5_type(a5), Function::argument_6_type(a6));
|
|
};
|
|
|
|
template<class Function, class Object,
|
|
class A1,
|
|
class A2,
|
|
class A4,
|
|
class A5,
|
|
class A6> inline bndr_obj_1_2_4_5_6<Function>
|
|
bind_obj_1_2_4_5_6(Object& oi, const Function &f, A1 a1,
|
|
A2 a2,
|
|
A4 a4,
|
|
A5 a5,
|
|
A6 a6) {
|
|
return bndr_obj_1_2_4_5_6<Function>(static_cast<Function::object_type&>(oi), f, Function::first_argument_type(a1), Function::second_argument_type(a2), Function::argument_4_type(a4), Function::argument_5_type(a5), Function::argument_6_type(a6));
|
|
};
|
|
|
|
|
|
|
|
// Template Functions for binding const obj&pmf Ref of arity 6 to arity 1
|
|
|
|
template<class Function, const class Object,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6> inline bndr_const_obj_2_3_4_5_6<Function>
|
|
bind_const_obj_2_3_4_5_6(const Object& oi, const Function &f, A2 a2,
|
|
A3 a3,
|
|
A4 a4,
|
|
A5 a5,
|
|
A6 a6) {
|
|
return bndr_const_obj_2_3_4_5_6<Function>(static_cast<Function::object_type&>(oi), f, Function::second_argument_type(a2), Function::argument_3_type(a3), Function::argument_4_type(a4), Function::argument_5_type(a5), Function::argument_6_type(a6));
|
|
};
|
|
|
|
template<class Function, const class Object,
|
|
class A1,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6> inline bndr_const_obj_1_3_4_5_6<Function>
|
|
bind_const_obj_1_3_4_5_6(const Object& oi, const Function &f, A1 a1,
|
|
A3 a3,
|
|
A4 a4,
|
|
A5 a5,
|
|
A6 a6) {
|
|
return bndr_const_obj_1_3_4_5_6<Function>(static_cast<Function::object_type&>(oi), f, Function::first_argument_type(a1), Function::argument_3_type(a3), Function::argument_4_type(a4), Function::argument_5_type(a5), Function::argument_6_type(a6));
|
|
};
|
|
|
|
template<class Function, const class Object,
|
|
class A1,
|
|
class A2,
|
|
class A4,
|
|
class A5,
|
|
class A6> inline bndr_const_obj_1_2_4_5_6<Function>
|
|
bind_const_obj_1_2_4_5_6(const Object& oi, const Function &f, A1 a1,
|
|
A2 a2,
|
|
A4 a4,
|
|
A5 a5,
|
|
A6 a6) {
|
|
return bndr_const_obj_1_2_4_5_6<Function>(static_cast<Function::object_type&>(oi), f, Function::first_argument_type(a1), Function::second_argument_type(a2), Function::argument_4_type(a4), Function::argument_5_type(a5), Function::argument_6_type(a6));
|
|
};
|
|
|
|
|
|
|
|
//
|
|
// binders for arity 2
|
|
//
|
|
|
|
|
|
// Template Classes for binding arity 2 to arity 1
|
|
|
|
|
|
// Template Classes for binding function ptrs of arity 2 to arity 1
|
|
|
|
template<class Function> class std_bndr_2 :
|
|
public std_arity1fp<Function::first_argument_type, Function::result_type> {
|
|
public:
|
|
typedef Function::result_type ( __stdcall *const pf2type) (Function::first_argument_type, Function::second_argument_type);
|
|
explicit inline std_bndr_2(const Function &f, Function::second_argument_type a2) :
|
|
std_arity1fp<Function::first_argument_type, Function::result_type>(reinterpret_cast<pf1type>(f.pf0)), arg2val(a2) {}
|
|
inline std_bndr_2(const std_bndr_2& bndri) :
|
|
std_arity1fp<Function::first_argument_type, Function::result_type>(reinterpret_cast<pf1type>(bndri.pf0)), arg2val(bndri.arg2val) {}
|
|
inline Function::result_type operator()(Function::first_argument_type a1) const {
|
|
pf2type pf = reinterpret_cast<pf2type>(pf0);
|
|
return pf(a1, arg2val);
|
|
}
|
|
public:
|
|
Function::second_argument_type arg2val;
|
|
};
|
|
|
|
template<class Function> class std_bndr_1 :
|
|
public std_arity1fp<Function::second_argument_type, Function::result_type> {
|
|
public:
|
|
typedef Function::result_type ( __stdcall *const pf2type) (Function::first_argument_type, Function::second_argument_type);
|
|
explicit inline std_bndr_1(const Function &f, Function::first_argument_type a1) :
|
|
std_arity1fp<Function::second_argument_type, Function::result_type>(reinterpret_cast<pf1type>(f.pf0)), arg1val(a1) {}
|
|
inline std_bndr_1(const std_bndr_1& bndri) :
|
|
std_arity1fp<Function::second_argument_type, Function::result_type>(reinterpret_cast<pf1type>(bndri.pf0)), arg1val(bndri.arg1val) {}
|
|
inline Function::result_type operator()(Function::second_argument_type a2) const {
|
|
pf2type pf = reinterpret_cast<pf2type>(pf0);
|
|
return pf(arg1val, a2);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
};
|
|
|
|
|
|
|
|
// Template Classes for binding pmf of arity 2 to arity 1
|
|
|
|
template<class Function> class std_bndr_mf_2 :
|
|
public std_arity1pmf<Function::object_type, Function::first_argument_type, Function::result_type>,
|
|
private std_arity2_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type, Function::result_type> {
|
|
public:
|
|
explicit inline std_bndr_mf_2(const Function &f, Function::second_argument_type a2) :
|
|
std_arity1pmf<Function::object_type, Function::first_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(f.pmf0)), std_arity2_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type, Function::result_type>(f), arg2val(a2) {}
|
|
inline std_bndr_mf_2(const std_bndr_mf_2& bndri) :
|
|
std_arity1pmf<Function::object_type, Function::first_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(bndri.pmf0)), std_arity2_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type, Function::result_type>(bndri), arg2val(bndri.arg2val) {}
|
|
inline virtual Function::result_type operator()(Function::object_type& o, Function::first_argument_type a1) const {
|
|
pmf2type pmf = reinterpret_cast<pmf2type>(pmf0);
|
|
return (o.*pmf)(a1, arg2val);
|
|
}
|
|
public:
|
|
Function::second_argument_type arg2val;
|
|
};
|
|
|
|
template<class Function> class std_bndr_mf_1 :
|
|
public std_arity1pmf<Function::object_type, Function::second_argument_type, Function::result_type>,
|
|
private std_arity2_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type, Function::result_type> {
|
|
public:
|
|
explicit inline std_bndr_mf_1(const Function &f, Function::first_argument_type a1) :
|
|
std_arity1pmf<Function::object_type, Function::second_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(f.pmf0)), std_arity2_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type, Function::result_type>(f), arg1val(a1) {}
|
|
inline std_bndr_mf_1(const std_bndr_mf_1& bndri) :
|
|
std_arity1pmf<Function::object_type, Function::second_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(bndri.pmf0)), std_arity2_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type, Function::result_type>(bndri), arg1val(bndri.arg1val) {}
|
|
inline virtual Function::result_type operator()(Function::object_type& o, Function::second_argument_type a2) const {
|
|
pmf2type pmf = reinterpret_cast<pmf2type>(pmf0);
|
|
return (o.*pmf)(arg1val, a2);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
};
|
|
|
|
|
|
|
|
// Template Classes for binding const pmf of arity 2 to arity 1
|
|
|
|
template<class Function> class std_bndr_const_mf_2 :
|
|
public std_arity1pmf_const<Function::object_type, Function::first_argument_type, Function::result_type>,
|
|
private std_arity2_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type, Function::result_type> {
|
|
public:
|
|
explicit inline std_bndr_const_mf_2(const Function &f, Function::second_argument_type a2) :
|
|
std_arity1pmf_const<Function::object_type, Function::first_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(f.pmf0)), std_arity2_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type, Function::result_type>(f), arg2val(a2) {}
|
|
inline std_bndr_const_mf_2(const std_bndr_const_mf_2& bndri) :
|
|
std_arity1pmf_const<Function::object_type, Function::first_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(bndri.pmf0)), std_arity2_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type, Function::result_type>(bndri), arg2val(bndri.arg2val) {}
|
|
inline virtual Function::result_type operator()(Function::object_type& o, Function::first_argument_type a1) const {
|
|
pmf2type pmf = reinterpret_cast<pmf2type>(pmf0);
|
|
return (o.*pmf)(a1, arg2val);
|
|
}
|
|
public:
|
|
Function::second_argument_type arg2val;
|
|
};
|
|
|
|
template<class Function> class std_bndr_const_mf_1 :
|
|
public std_arity1pmf_const<Function::object_type, Function::second_argument_type, Function::result_type>,
|
|
private std_arity2_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type, Function::result_type> {
|
|
public:
|
|
explicit inline std_bndr_const_mf_1(const Function &f, Function::first_argument_type a1) :
|
|
std_arity1pmf_const<Function::object_type, Function::second_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(f.pmf0)), std_arity2_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type, Function::result_type>(f), arg1val(a1) {}
|
|
inline std_bndr_const_mf_1(const std_bndr_const_mf_1& bndri) :
|
|
std_arity1pmf_const<Function::object_type, Function::second_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(bndri.pmf0)), std_arity2_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type, Function::result_type>(bndri), arg1val(bndri.arg1val) {}
|
|
inline virtual Function::result_type operator()(Function::object_type& o, Function::second_argument_type a2) const {
|
|
pmf2type pmf = reinterpret_cast<pmf2type>(pmf0);
|
|
return (o.*pmf)(arg1val, a2);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
};
|
|
|
|
|
|
|
|
// Template Classes for binding obj&pmf Ref of arity 2 to arity 1
|
|
|
|
template<class Function> class std_bndr_obj_2 :
|
|
public std_arity1opmf<Function>,
|
|
private std_arity2_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type, Function::result_type> {
|
|
public:
|
|
explicit inline std_bndr_obj_2(Function::object_type& oi, const Function &f, Function::second_argument_type a2) :
|
|
std_arity1opmf<Function>(oi, reinterpret_cast<pmf1type>(f.pmf0)), std_arity2_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type, Function::result_type>(f), arg2val(a2) {}
|
|
inline std_bndr_obj_2(const std_bndr_obj_2& bndri) :
|
|
std_arity1opmf<Function>(bndri.objval, reinterpret_cast<pmf1type>(bndri.pmf0)), std_arity2_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type, Function::result_type>(bndri), arg2val(bndri.arg2val) {}
|
|
inline Function::result_type operator()(Function::first_argument_type a1) const {
|
|
pmf2type pmf = reinterpret_cast<pmf2type>(pmf0);
|
|
return (objval.*pmf)(a1, arg2val);
|
|
}
|
|
public:
|
|
Function::second_argument_type arg2val;
|
|
};
|
|
|
|
template<class Function> class std_bndr_obj_1 :
|
|
public std_arity1opmf<Function>,
|
|
private std_arity2_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type, Function::result_type> {
|
|
public:
|
|
explicit inline std_bndr_obj_1(Function::object_type& oi, const Function &f, Function::first_argument_type a1) :
|
|
std_arity1opmf<Function>(oi, reinterpret_cast<pmf1type>(f.pmf0)), std_arity2_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type, Function::result_type>(f), arg1val(a1) {}
|
|
inline std_bndr_obj_1(const std_bndr_obj_1& bndri) :
|
|
std_arity1opmf<Function>(bndri.objval, reinterpret_cast<pmf1type>(bndri.pmf0)), std_arity2_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type, Function::result_type>(bndri), arg1val(bndri.arg1val) {}
|
|
inline Function::result_type operator()(Function::second_argument_type a2) const {
|
|
pmf2type pmf = reinterpret_cast<pmf2type>(pmf0);
|
|
return (objval.*pmf)(arg1val, a2);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
};
|
|
|
|
|
|
|
|
// Template Classes for binding const obj&pmf Ref of arity 2 to arity 1
|
|
|
|
template<class Function> class std_bndr_const_obj_2 :
|
|
public std_arity1opmf_const<Function>,
|
|
private std_arity2_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type, Function::result_type> {
|
|
public:
|
|
explicit inline std_bndr_const_obj_2(const Function::object_type& oi, const Function &f, Function::second_argument_type a2) :
|
|
std_arity1opmf_const<Function>(oi, reinterpret_cast<pmf1type>(f.pmf0)), std_arity2_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type, Function::result_type>(f), arg2val(a2) {}
|
|
inline std_bndr_const_obj_2(const std_bndr_const_obj_2& bndri) :
|
|
std_arity1opmf_const<Function>(bndri.objval, reinterpret_cast<pmf1type>(bndri.pmf0)), std_arity2_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type, Function::result_type>(bndri), arg2val(bndri.arg2val) {}
|
|
inline Function::result_type operator()(Function::first_argument_type a1) const {
|
|
pmf2type pmf = reinterpret_cast<pmf2type>(pmf0);
|
|
return (objval.*pmf)(a1, arg2val);
|
|
}
|
|
public:
|
|
Function::second_argument_type arg2val;
|
|
};
|
|
|
|
template<class Function> class std_bndr_const_obj_1 :
|
|
public std_arity1opmf_const<Function>,
|
|
private std_arity2_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type, Function::result_type> {
|
|
public:
|
|
explicit inline std_bndr_const_obj_1(const Function::object_type& oi, const Function &f, Function::first_argument_type a1) :
|
|
std_arity1opmf_const<Function>(oi, reinterpret_cast<pmf1type>(f.pmf0)), std_arity2_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type, Function::result_type>(f), arg1val(a1) {}
|
|
inline std_bndr_const_obj_1(const std_bndr_const_obj_1& bndri) :
|
|
std_arity1opmf_const<Function>(bndri.objval, reinterpret_cast<pmf1type>(bndri.pmf0)), std_arity2_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type, Function::result_type>(bndri), arg1val(bndri.arg1val) {}
|
|
inline Function::result_type operator()(Function::second_argument_type a2) const {
|
|
pmf2type pmf = reinterpret_cast<pmf2type>(pmf0);
|
|
return (objval.*pmf)(arg1val, a2);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
};
|
|
|
|
|
|
|
|
// Template Functions for binding arity 2 to arity 1
|
|
|
|
|
|
// Template Functions for binding function ptrs of arity 2 to arity 1
|
|
|
|
template<class Function, class A2> inline std_bndr_2<Function>
|
|
std_bind_fp_2(const Function &f, A2 a2) {
|
|
return std_bndr_2<Function>(f, Function::second_argument_type(a2));
|
|
};
|
|
|
|
template<class Function, class A1> inline std_bndr_1<Function>
|
|
std_bind_fp_1(const Function &f, A1 a1) {
|
|
return std_bndr_1<Function>(f, Function::first_argument_type(a1));
|
|
};
|
|
|
|
|
|
|
|
// Template Functions for binding pmf of arity 2 to arity 1
|
|
|
|
template<class Function, class A2> inline std_bndr_mf_2<Function>
|
|
std_bind_mf_2(const Function &f, A2 a2) {
|
|
return std_bndr_mf_2<Function>(f, Function::second_argument_type(a2));
|
|
};
|
|
|
|
template<class Function, class A1> inline std_bndr_mf_1<Function>
|
|
std_bind_mf_1(const Function &f, A1 a1) {
|
|
return std_bndr_mf_1<Function>(f, Function::first_argument_type(a1));
|
|
};
|
|
|
|
|
|
|
|
// Template Functions for binding const pmf of arity 2 to arity 1
|
|
|
|
template<class Function, class A2> inline std_bndr_const_mf_2<Function>
|
|
std_bind_const_mf_2(const Function &f, A2 a2) {
|
|
return std_bndr_const_mf_2<Function>(f, Function::second_argument_type(a2));
|
|
};
|
|
|
|
template<class Function, class A1> inline std_bndr_const_mf_1<Function>
|
|
std_bind_const_mf_1(const Function &f, A1 a1) {
|
|
return std_bndr_const_mf_1<Function>(f, Function::first_argument_type(a1));
|
|
};
|
|
|
|
|
|
|
|
// Template Functions for binding obj&pmf Ref of arity 2 to arity 1
|
|
|
|
template<class Function, class Object,
|
|
class A2> inline std_bndr_obj_2<Function>
|
|
std_bind_obj_2(Object& oi, const Function &f, A2 a2) {
|
|
return std_bndr_obj_2<Function>(static_cast<Function::object_type&>(oi), f, Function::second_argument_type(a2));
|
|
};
|
|
|
|
template<class Function, class Object,
|
|
class A1> inline std_bndr_obj_1<Function>
|
|
std_bind_obj_1(Object& oi, const Function &f, A1 a1) {
|
|
return std_bndr_obj_1<Function>(static_cast<Function::object_type&>(oi), f, Function::first_argument_type(a1));
|
|
};
|
|
|
|
|
|
|
|
// Template Functions for binding const obj&pmf Ref of arity 2 to arity 1
|
|
|
|
template<class Function, const class Object,
|
|
class A2> inline std_bndr_const_obj_2<Function>
|
|
std_bind_const_obj_2(const Object& oi, const Function &f, A2 a2) {
|
|
return std_bndr_const_obj_2<Function>(static_cast<Function::object_type&>(oi), f, Function::second_argument_type(a2));
|
|
};
|
|
|
|
template<class Function, const class Object,
|
|
class A1> inline std_bndr_const_obj_1<Function>
|
|
std_bind_const_obj_1(const Object& oi, const Function &f, A1 a1) {
|
|
return std_bndr_const_obj_1<Function>(static_cast<Function::object_type&>(oi), f, Function::first_argument_type(a1));
|
|
};
|
|
|
|
|
|
|
|
//
|
|
// binders for arity 3
|
|
//
|
|
|
|
|
|
// Template Classes for binding arity 3 to arity 1
|
|
|
|
|
|
// Template Classes for binding function ptrs of arity 3 to arity 1
|
|
|
|
template<class Function> class std_bndr_2_3 :
|
|
public std_arity1fp<Function::first_argument_type, Function::result_type> {
|
|
public:
|
|
typedef Function::result_type ( __stdcall *const pf3type) (Function::first_argument_type, Function::second_argument_type, Function::argument_3_type);
|
|
explicit inline std_bndr_2_3(const Function &f, Function::second_argument_type a2,
|
|
Function::argument_3_type a3) :
|
|
std_arity1fp<Function::first_argument_type, Function::result_type>(reinterpret_cast<pf1type>(f.pf0)), arg2val(a2), arg3val(a3) {}
|
|
inline std_bndr_2_3(const std_bndr_2_3& bndri) :
|
|
std_arity1fp<Function::first_argument_type, Function::result_type>(reinterpret_cast<pf1type>(bndri.pf0)), arg2val(bndri.arg2val), arg3val(bndri.arg3val) {}
|
|
inline Function::result_type operator()(Function::first_argument_type a1) const {
|
|
pf3type pf = reinterpret_cast<pf3type>(pf0);
|
|
return pf(a1, arg2val, arg3val);
|
|
}
|
|
public:
|
|
Function::second_argument_type arg2val;
|
|
Function::argument_3_type arg3val;
|
|
};
|
|
|
|
template<class Function> class std_bndr_1_3 :
|
|
public std_arity1fp<Function::second_argument_type, Function::result_type> {
|
|
public:
|
|
typedef Function::result_type ( __stdcall *const pf3type) (Function::first_argument_type, Function::second_argument_type, Function::argument_3_type);
|
|
explicit inline std_bndr_1_3(const Function &f, Function::first_argument_type a1,
|
|
Function::argument_3_type a3) :
|
|
std_arity1fp<Function::second_argument_type, Function::result_type>(reinterpret_cast<pf1type>(f.pf0)), arg1val(a1), arg3val(a3) {}
|
|
inline std_bndr_1_3(const std_bndr_1_3& bndri) :
|
|
std_arity1fp<Function::second_argument_type, Function::result_type>(reinterpret_cast<pf1type>(bndri.pf0)), arg1val(bndri.arg1val), arg3val(bndri.arg3val) {}
|
|
inline Function::result_type operator()(Function::second_argument_type a2) const {
|
|
pf3type pf = reinterpret_cast<pf3type>(pf0);
|
|
return pf(arg1val, a2, arg3val);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::argument_3_type arg3val;
|
|
};
|
|
|
|
template<class Function> class std_bndr_1_2 :
|
|
public std_arity1fp<Function::argument_3_type, Function::result_type> {
|
|
public:
|
|
typedef Function::result_type ( __stdcall *const pf3type) (Function::first_argument_type, Function::second_argument_type, Function::argument_3_type);
|
|
explicit inline std_bndr_1_2(const Function &f, Function::first_argument_type a1,
|
|
Function::second_argument_type a2) :
|
|
std_arity1fp<Function::argument_3_type, Function::result_type>(reinterpret_cast<pf1type>(f.pf0)), arg1val(a1), arg2val(a2) {}
|
|
inline std_bndr_1_2(const std_bndr_1_2& bndri) :
|
|
std_arity1fp<Function::argument_3_type, Function::result_type>(reinterpret_cast<pf1type>(bndri.pf0)), arg1val(bndri.arg1val), arg2val(bndri.arg2val) {}
|
|
inline Function::result_type operator()(Function::argument_3_type a3) const {
|
|
pf3type pf = reinterpret_cast<pf3type>(pf0);
|
|
return pf(arg1val, arg2val, a3);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::second_argument_type arg2val;
|
|
};
|
|
|
|
|
|
|
|
// Template Classes for binding pmf of arity 3 to arity 1
|
|
|
|
template<class Function> class std_bndr_mf_2_3 :
|
|
public std_arity1pmf<Function::object_type, Function::first_argument_type, Function::result_type>,
|
|
private std_arity3_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type> {
|
|
public:
|
|
explicit inline std_bndr_mf_2_3(const Function &f, Function::second_argument_type a2, Function::argument_3_type a3) :
|
|
std_arity1pmf<Function::object_type, Function::first_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(f.pmf0)), std_arity3_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type>(f), arg2val(a2), arg3val(a3) {}
|
|
inline std_bndr_mf_2_3(const std_bndr_mf_2_3& bndri) :
|
|
std_arity1pmf<Function::object_type, Function::first_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(bndri.pmf0)), std_arity3_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type>(bndri), arg2val(bndri.arg2val), arg3val(bndri.arg3val) {}
|
|
inline virtual Function::result_type operator()(Function::object_type& o, Function::first_argument_type a1) const {
|
|
pmf3type pmf = reinterpret_cast<pmf3type>(pmf0);
|
|
return (o.*pmf)(a1, arg2val, arg3val);
|
|
}
|
|
public:
|
|
Function::second_argument_type arg2val;
|
|
Function::argument_3_type arg3val;
|
|
};
|
|
|
|
template<class Function> class std_bndr_mf_1_3 :
|
|
public std_arity1pmf<Function::object_type, Function::second_argument_type, Function::result_type>,
|
|
private std_arity3_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type> {
|
|
public:
|
|
explicit inline std_bndr_mf_1_3(const Function &f, Function::first_argument_type a1, Function::argument_3_type a3) :
|
|
std_arity1pmf<Function::object_type, Function::second_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(f.pmf0)), std_arity3_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type>(f), arg1val(a1), arg3val(a3) {}
|
|
inline std_bndr_mf_1_3(const std_bndr_mf_1_3& bndri) :
|
|
std_arity1pmf<Function::object_type, Function::second_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(bndri.pmf0)), std_arity3_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type>(bndri), arg1val(bndri.arg1val), arg3val(bndri.arg3val) {}
|
|
inline virtual Function::result_type operator()(Function::object_type& o, Function::second_argument_type a2) const {
|
|
pmf3type pmf = reinterpret_cast<pmf3type>(pmf0);
|
|
return (o.*pmf)(arg1val, a2, arg3val);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::argument_3_type arg3val;
|
|
};
|
|
|
|
template<class Function> class std_bndr_mf_1_2 :
|
|
public std_arity1pmf<Function::object_type, Function::argument_3_type, Function::result_type>,
|
|
private std_arity3_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type> {
|
|
public:
|
|
explicit inline std_bndr_mf_1_2(const Function &f, Function::first_argument_type a1, Function::second_argument_type a2) :
|
|
std_arity1pmf<Function::object_type, Function::argument_3_type, Function::result_type>(reinterpret_cast<pmf1type>(f.pmf0)), std_arity3_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type>(f), arg1val(a1), arg2val(a2) {}
|
|
inline std_bndr_mf_1_2(const std_bndr_mf_1_2& bndri) :
|
|
std_arity1pmf<Function::object_type, Function::argument_3_type, Function::result_type>(reinterpret_cast<pmf1type>(bndri.pmf0)), std_arity3_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type>(bndri), arg1val(bndri.arg1val), arg2val(bndri.arg2val) {}
|
|
inline virtual Function::result_type operator()(Function::object_type& o, Function::argument_3_type a3) const {
|
|
pmf3type pmf = reinterpret_cast<pmf3type>(pmf0);
|
|
return (o.*pmf)(arg1val, arg2val, a3);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::second_argument_type arg2val;
|
|
};
|
|
|
|
|
|
|
|
// Template Classes for binding const pmf of arity 3 to arity 1
|
|
|
|
template<class Function> class std_bndr_const_mf_2_3 :
|
|
public std_arity1pmf_const<Function::object_type, Function::first_argument_type, Function::result_type>,
|
|
private std_arity3_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type> {
|
|
public:
|
|
explicit inline std_bndr_const_mf_2_3(const Function &f, Function::second_argument_type a2, Function::argument_3_type a3) :
|
|
std_arity1pmf_const<Function::object_type, Function::first_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(f.pmf0)), std_arity3_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type>(f), arg2val(a2), arg3val(a3) {}
|
|
inline std_bndr_const_mf_2_3(const std_bndr_const_mf_2_3& bndri) :
|
|
std_arity1pmf_const<Function::object_type, Function::first_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(bndri.pmf0)), std_arity3_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type>(bndri), arg2val(bndri.arg2val), arg3val(bndri.arg3val) {}
|
|
inline virtual Function::result_type operator()(Function::object_type& o, Function::first_argument_type a1) const {
|
|
pmf3type pmf = reinterpret_cast<pmf3type>(pmf0);
|
|
return (o.*pmf)(a1, arg2val, arg3val);
|
|
}
|
|
public:
|
|
Function::second_argument_type arg2val;
|
|
Function::argument_3_type arg3val;
|
|
};
|
|
|
|
template<class Function> class std_bndr_const_mf_1_3 :
|
|
public std_arity1pmf_const<Function::object_type, Function::second_argument_type, Function::result_type>,
|
|
private std_arity3_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type> {
|
|
public:
|
|
explicit inline std_bndr_const_mf_1_3(const Function &f, Function::first_argument_type a1, Function::argument_3_type a3) :
|
|
std_arity1pmf_const<Function::object_type, Function::second_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(f.pmf0)), std_arity3_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type>(f), arg1val(a1), arg3val(a3) {}
|
|
inline std_bndr_const_mf_1_3(const std_bndr_const_mf_1_3& bndri) :
|
|
std_arity1pmf_const<Function::object_type, Function::second_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(bndri.pmf0)), std_arity3_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type>(bndri), arg1val(bndri.arg1val), arg3val(bndri.arg3val) {}
|
|
inline virtual Function::result_type operator()(Function::object_type& o, Function::second_argument_type a2) const {
|
|
pmf3type pmf = reinterpret_cast<pmf3type>(pmf0);
|
|
return (o.*pmf)(arg1val, a2, arg3val);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::argument_3_type arg3val;
|
|
};
|
|
|
|
template<class Function> class std_bndr_const_mf_1_2 :
|
|
public std_arity1pmf_const<Function::object_type, Function::argument_3_type, Function::result_type>,
|
|
private std_arity3_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type> {
|
|
public:
|
|
explicit inline std_bndr_const_mf_1_2(const Function &f, Function::first_argument_type a1, Function::second_argument_type a2) :
|
|
std_arity1pmf_const<Function::object_type, Function::argument_3_type, Function::result_type>(reinterpret_cast<pmf1type>(f.pmf0)), std_arity3_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type>(f), arg1val(a1), arg2val(a2) {}
|
|
inline std_bndr_const_mf_1_2(const std_bndr_const_mf_1_2& bndri) :
|
|
std_arity1pmf_const<Function::object_type, Function::argument_3_type, Function::result_type>(reinterpret_cast<pmf1type>(bndri.pmf0)), std_arity3_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type>(bndri), arg1val(bndri.arg1val), arg2val(bndri.arg2val) {}
|
|
inline virtual Function::result_type operator()(Function::object_type& o, Function::argument_3_type a3) const {
|
|
pmf3type pmf = reinterpret_cast<pmf3type>(pmf0);
|
|
return (o.*pmf)(arg1val, arg2val, a3);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::second_argument_type arg2val;
|
|
};
|
|
|
|
|
|
|
|
// Template Classes for binding obj&pmf Ref of arity 3 to arity 1
|
|
|
|
template<class Function> class std_bndr_obj_2_3 :
|
|
public std_arity1opmf<Function>,
|
|
private std_arity3_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type> {
|
|
public:
|
|
explicit inline std_bndr_obj_2_3(Function::object_type& oi, const Function &f, Function::second_argument_type a2, Function::argument_3_type a3) :
|
|
std_arity1opmf<Function>(oi, reinterpret_cast<pmf1type>(f.pmf0)), std_arity3_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type>(f), arg2val(a2), arg3val(a3) {}
|
|
inline std_bndr_obj_2_3(const std_bndr_obj_2_3& bndri) :
|
|
std_arity1opmf<Function>(bndri.objval, reinterpret_cast<pmf1type>(bndri.pmf0)), std_arity3_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type>(bndri), arg2val(bndri.arg2val), arg3val(bndri.arg3val) {}
|
|
inline Function::result_type operator()(Function::first_argument_type a1) const {
|
|
pmf3type pmf = reinterpret_cast<pmf3type>(pmf0);
|
|
return (objval.*pmf)(a1, arg2val, arg3val);
|
|
}
|
|
public:
|
|
Function::second_argument_type arg2val;
|
|
Function::argument_3_type arg3val;
|
|
};
|
|
|
|
template<class Function> class std_bndr_obj_1_3 :
|
|
public std_arity1opmf<Function>,
|
|
private std_arity3_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type> {
|
|
public:
|
|
explicit inline std_bndr_obj_1_3(Function::object_type& oi, const Function &f, Function::first_argument_type a1, Function::argument_3_type a3) :
|
|
std_arity1opmf<Function>(oi, reinterpret_cast<pmf1type>(f.pmf0)), std_arity3_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type>(f), arg1val(a1), arg3val(a3) {}
|
|
inline std_bndr_obj_1_3(const std_bndr_obj_1_3& bndri) :
|
|
std_arity1opmf<Function>(bndri.objval, reinterpret_cast<pmf1type>(bndri.pmf0)), std_arity3_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type>(bndri), arg1val(bndri.arg1val), arg3val(bndri.arg3val) {}
|
|
inline Function::result_type operator()(Function::second_argument_type a2) const {
|
|
pmf3type pmf = reinterpret_cast<pmf3type>(pmf0);
|
|
return (objval.*pmf)(arg1val, a2, arg3val);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::argument_3_type arg3val;
|
|
};
|
|
|
|
template<class Function> class std_bndr_obj_1_2 :
|
|
public std_arity1opmf<Function>,
|
|
private std_arity3_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type> {
|
|
public:
|
|
explicit inline std_bndr_obj_1_2(Function::object_type& oi, const Function &f, Function::first_argument_type a1, Function::second_argument_type a2) :
|
|
std_arity1opmf<Function>(oi, reinterpret_cast<pmf1type>(f.pmf0)), std_arity3_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type>(f), arg1val(a1), arg2val(a2) {}
|
|
inline std_bndr_obj_1_2(const std_bndr_obj_1_2& bndri) :
|
|
std_arity1opmf<Function>(bndri.objval, reinterpret_cast<pmf1type>(bndri.pmf0)), std_arity3_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type>(bndri), arg1val(bndri.arg1val), arg2val(bndri.arg2val) {}
|
|
inline Function::result_type operator()(Function::argument_3_type a3) const {
|
|
pmf3type pmf = reinterpret_cast<pmf3type>(pmf0);
|
|
return (objval.*pmf)(arg1val, arg2val, a3);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::second_argument_type arg2val;
|
|
};
|
|
|
|
|
|
|
|
// Template Classes for binding const obj&pmf Ref of arity 3 to arity 1
|
|
|
|
template<class Function> class std_bndr_const_obj_2_3 :
|
|
public std_arity1opmf_const<Function>,
|
|
private std_arity3_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type> {
|
|
public:
|
|
explicit inline std_bndr_const_obj_2_3(const Function::object_type& oi, const Function &f, Function::second_argument_type a2, Function::argument_3_type a3) :
|
|
std_arity1opmf_const<Function>(oi, reinterpret_cast<pmf1type>(f.pmf0)), std_arity3_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type>(f), arg2val(a2), arg3val(a3) {}
|
|
inline std_bndr_const_obj_2_3(const std_bndr_const_obj_2_3& bndri) :
|
|
std_arity1opmf_const<Function>(bndri.objval, reinterpret_cast<pmf1type>(bndri.pmf0)), std_arity3_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type>(bndri), arg2val(bndri.arg2val), arg3val(bndri.arg3val) {}
|
|
inline Function::result_type operator()(Function::first_argument_type a1) const {
|
|
pmf3type pmf = reinterpret_cast<pmf3type>(pmf0);
|
|
return (objval.*pmf)(a1, arg2val, arg3val);
|
|
}
|
|
public:
|
|
Function::second_argument_type arg2val;
|
|
Function::argument_3_type arg3val;
|
|
};
|
|
|
|
template<class Function> class std_bndr_const_obj_1_3 :
|
|
public std_arity1opmf_const<Function>,
|
|
private std_arity3_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type> {
|
|
public:
|
|
explicit inline std_bndr_const_obj_1_3(const Function::object_type& oi, const Function &f, Function::first_argument_type a1, Function::argument_3_type a3) :
|
|
std_arity1opmf_const<Function>(oi, reinterpret_cast<pmf1type>(f.pmf0)), std_arity3_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type>(f), arg1val(a1), arg3val(a3) {}
|
|
inline std_bndr_const_obj_1_3(const std_bndr_const_obj_1_3& bndri) :
|
|
std_arity1opmf_const<Function>(bndri.objval, reinterpret_cast<pmf1type>(bndri.pmf0)), std_arity3_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type>(bndri), arg1val(bndri.arg1val), arg3val(bndri.arg3val) {}
|
|
inline Function::result_type operator()(Function::second_argument_type a2) const {
|
|
pmf3type pmf = reinterpret_cast<pmf3type>(pmf0);
|
|
return (objval.*pmf)(arg1val, a2, arg3val);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::argument_3_type arg3val;
|
|
};
|
|
|
|
template<class Function> class std_bndr_const_obj_1_2 :
|
|
public std_arity1opmf_const<Function>,
|
|
private std_arity3_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type> {
|
|
public:
|
|
explicit inline std_bndr_const_obj_1_2(const Function::object_type& oi, const Function &f, Function::first_argument_type a1, Function::second_argument_type a2) :
|
|
std_arity1opmf_const<Function>(oi, reinterpret_cast<pmf1type>(f.pmf0)), std_arity3_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type>(f), arg1val(a1), arg2val(a2) {}
|
|
inline std_bndr_const_obj_1_2(const std_bndr_const_obj_1_2& bndri) :
|
|
std_arity1opmf_const<Function>(bndri.objval, reinterpret_cast<pmf1type>(bndri.pmf0)), std_arity3_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type, Function::result_type>(bndri), arg1val(bndri.arg1val), arg2val(bndri.arg2val) {}
|
|
inline Function::result_type operator()(Function::argument_3_type a3) const {
|
|
pmf3type pmf = reinterpret_cast<pmf3type>(pmf0);
|
|
return (objval.*pmf)(arg1val, arg2val, a3);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::second_argument_type arg2val;
|
|
};
|
|
|
|
|
|
|
|
// Template Functions for binding arity 3 to arity 1
|
|
|
|
|
|
// Template Functions for binding function ptrs of arity 3 to arity 1
|
|
|
|
template<class Function, class A2,
|
|
class A3> inline std_bndr_2_3<Function>
|
|
std_bind_fp_2_3(const Function &f, A2 a2,
|
|
A3 a3) {
|
|
return std_bndr_2_3<Function>(f, Function::second_argument_type(a2), Function::argument_3_type(a3));
|
|
};
|
|
|
|
template<class Function, class A1,
|
|
class A3> inline std_bndr_1_3<Function>
|
|
std_bind_fp_1_3(const Function &f, A1 a1,
|
|
A3 a3) {
|
|
return std_bndr_1_3<Function>(f, Function::first_argument_type(a1), Function::argument_3_type(a3));
|
|
};
|
|
|
|
template<class Function, class A1,
|
|
class A2> inline std_bndr_1_2<Function>
|
|
std_bind_fp_1_2(const Function &f, A1 a1,
|
|
A2 a2) {
|
|
return std_bndr_1_2<Function>(f, Function::first_argument_type(a1), Function::second_argument_type(a2));
|
|
};
|
|
|
|
|
|
|
|
// Template Functions for binding pmf of arity 3 to arity 1
|
|
|
|
template<class Function, class A2,
|
|
class A3> inline std_bndr_mf_2_3<Function>
|
|
std_bind_mf_2_3(const Function &f, A2 a2,
|
|
A3 a3) {
|
|
return std_bndr_mf_2_3<Function>(f, Function::second_argument_type(a2), Function::argument_3_type(a3));
|
|
};
|
|
|
|
template<class Function, class A1,
|
|
class A3> inline std_bndr_mf_1_3<Function>
|
|
std_bind_mf_1_3(const Function &f, A1 a1,
|
|
A3 a3) {
|
|
return std_bndr_mf_1_3<Function>(f, Function::first_argument_type(a1), Function::argument_3_type(a3));
|
|
};
|
|
|
|
template<class Function, class A1,
|
|
class A2> inline std_bndr_mf_1_2<Function>
|
|
std_bind_mf_1_2(const Function &f, A1 a1,
|
|
A2 a2) {
|
|
return std_bndr_mf_1_2<Function>(f, Function::first_argument_type(a1), Function::second_argument_type(a2));
|
|
};
|
|
|
|
|
|
|
|
// Template Functions for binding const pmf of arity 3 to arity 1
|
|
|
|
template<class Function, class A2,
|
|
class A3> inline std_bndr_const_mf_2_3<Function>
|
|
std_bind_const_mf_2_3(const Function &f, A2 a2,
|
|
A3 a3) {
|
|
return std_bndr_const_mf_2_3<Function>(f, Function::second_argument_type(a2), Function::argument_3_type(a3));
|
|
};
|
|
|
|
template<class Function, class A1,
|
|
class A3> inline std_bndr_const_mf_1_3<Function>
|
|
std_bind_const_mf_1_3(const Function &f, A1 a1,
|
|
A3 a3) {
|
|
return std_bndr_const_mf_1_3<Function>(f, Function::first_argument_type(a1), Function::argument_3_type(a3));
|
|
};
|
|
|
|
template<class Function, class A1,
|
|
class A2> inline std_bndr_const_mf_1_2<Function>
|
|
std_bind_const_mf_1_2(const Function &f, A1 a1,
|
|
A2 a2) {
|
|
return std_bndr_const_mf_1_2<Function>(f, Function::first_argument_type(a1), Function::second_argument_type(a2));
|
|
};
|
|
|
|
|
|
|
|
// Template Functions for binding obj&pmf Ref of arity 3 to arity 1
|
|
|
|
template<class Function, class Object,
|
|
class A2,
|
|
class A3> inline std_bndr_obj_2_3<Function>
|
|
std_bind_obj_2_3(Object& oi, const Function &f, A2 a2,
|
|
A3 a3) {
|
|
return std_bndr_obj_2_3<Function>(static_cast<Function::object_type&>(oi), f, Function::second_argument_type(a2), Function::argument_3_type(a3));
|
|
};
|
|
|
|
template<class Function, class Object,
|
|
class A1,
|
|
class A3> inline std_bndr_obj_1_3<Function>
|
|
std_bind_obj_1_3(Object& oi, const Function &f, A1 a1,
|
|
A3 a3) {
|
|
return std_bndr_obj_1_3<Function>(static_cast<Function::object_type&>(oi), f, Function::first_argument_type(a1), Function::argument_3_type(a3));
|
|
};
|
|
|
|
template<class Function, class Object,
|
|
class A1,
|
|
class A2> inline std_bndr_obj_1_2<Function>
|
|
std_bind_obj_1_2(Object& oi, const Function &f, A1 a1,
|
|
A2 a2) {
|
|
return std_bndr_obj_1_2<Function>(static_cast<Function::object_type&>(oi), f, Function::first_argument_type(a1), Function::second_argument_type(a2));
|
|
};
|
|
|
|
|
|
|
|
// Template Functions for binding const obj&pmf Ref of arity 3 to arity 1
|
|
|
|
template<class Function, const class Object,
|
|
class A2,
|
|
class A3> inline std_bndr_const_obj_2_3<Function>
|
|
std_bind_const_obj_2_3(const Object& oi, const Function &f, A2 a2,
|
|
A3 a3) {
|
|
return std_bndr_const_obj_2_3<Function>(static_cast<Function::object_type&>(oi), f, Function::second_argument_type(a2), Function::argument_3_type(a3));
|
|
};
|
|
|
|
template<class Function, const class Object,
|
|
class A1,
|
|
class A3> inline std_bndr_const_obj_1_3<Function>
|
|
std_bind_const_obj_1_3(const Object& oi, const Function &f, A1 a1,
|
|
A3 a3) {
|
|
return std_bndr_const_obj_1_3<Function>(static_cast<Function::object_type&>(oi), f, Function::first_argument_type(a1), Function::argument_3_type(a3));
|
|
};
|
|
|
|
template<class Function, const class Object,
|
|
class A1,
|
|
class A2> inline std_bndr_const_obj_1_2<Function>
|
|
std_bind_const_obj_1_2(const Object& oi, const Function &f, A1 a1,
|
|
A2 a2) {
|
|
return std_bndr_const_obj_1_2<Function>(static_cast<Function::object_type&>(oi), f, Function::first_argument_type(a1), Function::second_argument_type(a2));
|
|
};
|
|
|
|
|
|
|
|
//
|
|
// binders for arity 4
|
|
//
|
|
|
|
|
|
// Template Classes for binding arity 4 to arity 1
|
|
|
|
|
|
// Template Classes for binding pmf of arity 4 to arity 1
|
|
|
|
template<class Function> class std_bndr_mf_2_3_4 :
|
|
public std_arity1pmf<Function::object_type, Function::first_argument_type, Function::result_type>,
|
|
private std_arity4_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type> {
|
|
public:
|
|
explicit inline std_bndr_mf_2_3_4(const Function &f, Function::second_argument_type a2, Function::argument_3_type a3, Function::argument_4_type a4) :
|
|
std_arity1pmf<Function::object_type, Function::first_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(f.pmf0)), std_arity4_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type>(f), arg2val(a2), arg3val(a3), arg4val(a4) {}
|
|
inline std_bndr_mf_2_3_4(const std_bndr_mf_2_3_4& bndri) :
|
|
std_arity1pmf<Function::object_type, Function::first_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(bndri.pmf0)), std_arity4_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type>(bndri), arg2val(bndri.arg2val), arg3val(bndri.arg3val), arg4val(bndri.arg4val) {}
|
|
inline virtual Function::result_type operator()(Function::object_type& o, Function::first_argument_type a1) const {
|
|
pmf4type pmf = reinterpret_cast<pmf4type>(pmf0);
|
|
return (o.*pmf)(a1, arg2val, arg3val, arg4val);
|
|
}
|
|
public:
|
|
Function::second_argument_type arg2val;
|
|
Function::argument_3_type arg3val;
|
|
Function::argument_4_type arg4val;
|
|
};
|
|
|
|
template<class Function> class std_bndr_mf_1_3_4 :
|
|
public std_arity1pmf<Function::object_type, Function::second_argument_type, Function::result_type>,
|
|
private std_arity4_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type> {
|
|
public:
|
|
explicit inline std_bndr_mf_1_3_4(const Function &f, Function::first_argument_type a1, Function::argument_3_type a3, Function::argument_4_type a4) :
|
|
std_arity1pmf<Function::object_type, Function::second_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(f.pmf0)), std_arity4_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type>(f), arg1val(a1), arg3val(a3), arg4val(a4) {}
|
|
inline std_bndr_mf_1_3_4(const std_bndr_mf_1_3_4& bndri) :
|
|
std_arity1pmf<Function::object_type, Function::second_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(bndri.pmf0)), std_arity4_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type>(bndri), arg1val(bndri.arg1val), arg3val(bndri.arg3val), arg4val(bndri.arg4val) {}
|
|
inline virtual Function::result_type operator()(Function::object_type& o, Function::second_argument_type a2) const {
|
|
pmf4type pmf = reinterpret_cast<pmf4type>(pmf0);
|
|
return (o.*pmf)(arg1val, a2, arg3val, arg4val);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::argument_3_type arg3val;
|
|
Function::argument_4_type arg4val;
|
|
};
|
|
|
|
template<class Function> class std_bndr_mf_1_2_4 :
|
|
public std_arity1pmf<Function::object_type, Function::argument_3_type, Function::result_type>,
|
|
private std_arity4_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type> {
|
|
public:
|
|
explicit inline std_bndr_mf_1_2_4(const Function &f, Function::first_argument_type a1, Function::second_argument_type a2, Function::argument_4_type a4) :
|
|
std_arity1pmf<Function::object_type, Function::argument_3_type, Function::result_type>(reinterpret_cast<pmf1type>(f.pmf0)), std_arity4_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type>(f), arg1val(a1), arg2val(a2), arg4val(a4) {}
|
|
inline std_bndr_mf_1_2_4(const std_bndr_mf_1_2_4& bndri) :
|
|
std_arity1pmf<Function::object_type, Function::argument_3_type, Function::result_type>(reinterpret_cast<pmf1type>(bndri.pmf0)), std_arity4_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type>(bndri), arg1val(bndri.arg1val), arg2val(bndri.arg2val), arg4val(bndri.arg4val) {}
|
|
inline virtual Function::result_type operator()(Function::object_type& o, Function::argument_3_type a3) const {
|
|
pmf4type pmf = reinterpret_cast<pmf4type>(pmf0);
|
|
return (o.*pmf)(arg1val, arg2val, a3, arg4val);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::second_argument_type arg2val;
|
|
Function::argument_4_type arg4val;
|
|
};
|
|
|
|
|
|
|
|
// Template Classes for binding const pmf of arity 4 to arity 1
|
|
|
|
template<class Function> class std_bndr_const_mf_2_3_4 :
|
|
public std_arity1pmf_const<Function::object_type, Function::first_argument_type, Function::result_type>,
|
|
private std_arity4_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type> {
|
|
public:
|
|
explicit inline std_bndr_const_mf_2_3_4(const Function &f, Function::second_argument_type a2, Function::argument_3_type a3, Function::argument_4_type a4) :
|
|
std_arity1pmf_const<Function::object_type, Function::first_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(f.pmf0)), std_arity4_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type>(f), arg2val(a2), arg3val(a3), arg4val(a4) {}
|
|
inline std_bndr_const_mf_2_3_4(const std_bndr_const_mf_2_3_4& bndri) :
|
|
std_arity1pmf_const<Function::object_type, Function::first_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(bndri.pmf0)), std_arity4_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type>(bndri), arg2val(bndri.arg2val), arg3val(bndri.arg3val), arg4val(bndri.arg4val) {}
|
|
inline virtual Function::result_type operator()(Function::object_type& o, Function::first_argument_type a1) const {
|
|
pmf4type pmf = reinterpret_cast<pmf4type>(pmf0);
|
|
return (o.*pmf)(a1, arg2val, arg3val, arg4val);
|
|
}
|
|
public:
|
|
Function::second_argument_type arg2val;
|
|
Function::argument_3_type arg3val;
|
|
Function::argument_4_type arg4val;
|
|
};
|
|
|
|
template<class Function> class std_bndr_const_mf_1_3_4 :
|
|
public std_arity1pmf_const<Function::object_type, Function::second_argument_type, Function::result_type>,
|
|
private std_arity4_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type> {
|
|
public:
|
|
explicit inline std_bndr_const_mf_1_3_4(const Function &f, Function::first_argument_type a1, Function::argument_3_type a3, Function::argument_4_type a4) :
|
|
std_arity1pmf_const<Function::object_type, Function::second_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(f.pmf0)), std_arity4_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type>(f), arg1val(a1), arg3val(a3), arg4val(a4) {}
|
|
inline std_bndr_const_mf_1_3_4(const std_bndr_const_mf_1_3_4& bndri) :
|
|
std_arity1pmf_const<Function::object_type, Function::second_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(bndri.pmf0)), std_arity4_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type>(bndri), arg1val(bndri.arg1val), arg3val(bndri.arg3val), arg4val(bndri.arg4val) {}
|
|
inline virtual Function::result_type operator()(Function::object_type& o, Function::second_argument_type a2) const {
|
|
pmf4type pmf = reinterpret_cast<pmf4type>(pmf0);
|
|
return (o.*pmf)(arg1val, a2, arg3val, arg4val);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::argument_3_type arg3val;
|
|
Function::argument_4_type arg4val;
|
|
};
|
|
|
|
template<class Function> class std_bndr_const_mf_1_2_4 :
|
|
public std_arity1pmf_const<Function::object_type, Function::argument_3_type, Function::result_type>,
|
|
private std_arity4_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type> {
|
|
public:
|
|
explicit inline std_bndr_const_mf_1_2_4(const Function &f, Function::first_argument_type a1, Function::second_argument_type a2, Function::argument_4_type a4) :
|
|
std_arity1pmf_const<Function::object_type, Function::argument_3_type, Function::result_type>(reinterpret_cast<pmf1type>(f.pmf0)), std_arity4_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type>(f), arg1val(a1), arg2val(a2), arg4val(a4) {}
|
|
inline std_bndr_const_mf_1_2_4(const std_bndr_const_mf_1_2_4& bndri) :
|
|
std_arity1pmf_const<Function::object_type, Function::argument_3_type, Function::result_type>(reinterpret_cast<pmf1type>(bndri.pmf0)), std_arity4_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type>(bndri), arg1val(bndri.arg1val), arg2val(bndri.arg2val), arg4val(bndri.arg4val) {}
|
|
inline virtual Function::result_type operator()(Function::object_type& o, Function::argument_3_type a3) const {
|
|
pmf4type pmf = reinterpret_cast<pmf4type>(pmf0);
|
|
return (o.*pmf)(arg1val, arg2val, a3, arg4val);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::second_argument_type arg2val;
|
|
Function::argument_4_type arg4val;
|
|
};
|
|
|
|
|
|
|
|
// Template Classes for binding obj&pmf Ref of arity 4 to arity 1
|
|
|
|
template<class Function> class std_bndr_obj_2_3_4 :
|
|
public std_arity1opmf<Function>,
|
|
private std_arity4_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type> {
|
|
public:
|
|
explicit inline std_bndr_obj_2_3_4(Function::object_type& oi, const Function &f, Function::second_argument_type a2, Function::argument_3_type a3, Function::argument_4_type a4) :
|
|
std_arity1opmf<Function>(oi, reinterpret_cast<pmf1type>(f.pmf0)), std_arity4_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type>(f), arg2val(a2), arg3val(a3), arg4val(a4) {}
|
|
inline std_bndr_obj_2_3_4(const std_bndr_obj_2_3_4& bndri) :
|
|
std_arity1opmf<Function>(bndri.objval, reinterpret_cast<pmf1type>(bndri.pmf0)), std_arity4_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type>(bndri), arg2val(bndri.arg2val), arg3val(bndri.arg3val), arg4val(bndri.arg4val) {}
|
|
inline Function::result_type operator()(Function::first_argument_type a1) const {
|
|
pmf4type pmf = reinterpret_cast<pmf4type>(pmf0);
|
|
return (objval.*pmf)(a1, arg2val, arg3val, arg4val);
|
|
}
|
|
public:
|
|
Function::second_argument_type arg2val;
|
|
Function::argument_3_type arg3val;
|
|
Function::argument_4_type arg4val;
|
|
};
|
|
|
|
template<class Function> class std_bndr_obj_1_3_4 :
|
|
public std_arity1opmf<Function>,
|
|
private std_arity4_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type> {
|
|
public:
|
|
explicit inline std_bndr_obj_1_3_4(Function::object_type& oi, const Function &f, Function::first_argument_type a1, Function::argument_3_type a3, Function::argument_4_type a4) :
|
|
std_arity1opmf<Function>(oi, reinterpret_cast<pmf1type>(f.pmf0)), std_arity4_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type>(f), arg1val(a1), arg3val(a3), arg4val(a4) {}
|
|
inline std_bndr_obj_1_3_4(const std_bndr_obj_1_3_4& bndri) :
|
|
std_arity1opmf<Function>(bndri.objval, reinterpret_cast<pmf1type>(bndri.pmf0)), std_arity4_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type>(bndri), arg1val(bndri.arg1val), arg3val(bndri.arg3val), arg4val(bndri.arg4val) {}
|
|
inline Function::result_type operator()(Function::second_argument_type a2) const {
|
|
pmf4type pmf = reinterpret_cast<pmf4type>(pmf0);
|
|
return (objval.*pmf)(arg1val, a2, arg3val, arg4val);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::argument_3_type arg3val;
|
|
Function::argument_4_type arg4val;
|
|
};
|
|
|
|
template<class Function> class std_bndr_obj_1_2_4 :
|
|
public std_arity1opmf<Function>,
|
|
private std_arity4_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type> {
|
|
public:
|
|
explicit inline std_bndr_obj_1_2_4(Function::object_type& oi, const Function &f, Function::first_argument_type a1, Function::second_argument_type a2, Function::argument_4_type a4) :
|
|
std_arity1opmf<Function>(oi, reinterpret_cast<pmf1type>(f.pmf0)), std_arity4_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type>(f), arg1val(a1), arg2val(a2), arg4val(a4) {}
|
|
inline std_bndr_obj_1_2_4(const std_bndr_obj_1_2_4& bndri) :
|
|
std_arity1opmf<Function>(bndri.objval, reinterpret_cast<pmf1type>(bndri.pmf0)), std_arity4_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type>(bndri), arg1val(bndri.arg1val), arg2val(bndri.arg2val), arg4val(bndri.arg4val) {}
|
|
inline Function::result_type operator()(Function::argument_3_type a3) const {
|
|
pmf4type pmf = reinterpret_cast<pmf4type>(pmf0);
|
|
return (objval.*pmf)(arg1val, arg2val, a3, arg4val);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::second_argument_type arg2val;
|
|
Function::argument_4_type arg4val;
|
|
};
|
|
|
|
|
|
|
|
// Template Classes for binding const obj&pmf Ref of arity 4 to arity 1
|
|
|
|
template<class Function> class std_bndr_const_obj_2_3_4 :
|
|
public std_arity1opmf_const<Function>,
|
|
private std_arity4_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type> {
|
|
public:
|
|
explicit inline std_bndr_const_obj_2_3_4(const Function::object_type& oi, const Function &f, Function::second_argument_type a2, Function::argument_3_type a3, Function::argument_4_type a4) :
|
|
std_arity1opmf_const<Function>(oi, reinterpret_cast<pmf1type>(f.pmf0)), std_arity4_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type>(f), arg2val(a2), arg3val(a3), arg4val(a4) {}
|
|
inline std_bndr_const_obj_2_3_4(const std_bndr_const_obj_2_3_4& bndri) :
|
|
std_arity1opmf_const<Function>(bndri.objval, reinterpret_cast<pmf1type>(bndri.pmf0)), std_arity4_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type>(bndri), arg2val(bndri.arg2val), arg3val(bndri.arg3val), arg4val(bndri.arg4val) {}
|
|
inline Function::result_type operator()(Function::first_argument_type a1) const {
|
|
pmf4type pmf = reinterpret_cast<pmf4type>(pmf0);
|
|
return (objval.*pmf)(a1, arg2val, arg3val, arg4val);
|
|
}
|
|
public:
|
|
Function::second_argument_type arg2val;
|
|
Function::argument_3_type arg3val;
|
|
Function::argument_4_type arg4val;
|
|
};
|
|
|
|
template<class Function> class std_bndr_const_obj_1_3_4 :
|
|
public std_arity1opmf_const<Function>,
|
|
private std_arity4_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type> {
|
|
public:
|
|
explicit inline std_bndr_const_obj_1_3_4(const Function::object_type& oi, const Function &f, Function::first_argument_type a1, Function::argument_3_type a3, Function::argument_4_type a4) :
|
|
std_arity1opmf_const<Function>(oi, reinterpret_cast<pmf1type>(f.pmf0)), std_arity4_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type>(f), arg1val(a1), arg3val(a3), arg4val(a4) {}
|
|
inline std_bndr_const_obj_1_3_4(const std_bndr_const_obj_1_3_4& bndri) :
|
|
std_arity1opmf_const<Function>(bndri.objval, reinterpret_cast<pmf1type>(bndri.pmf0)), std_arity4_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type>(bndri), arg1val(bndri.arg1val), arg3val(bndri.arg3val), arg4val(bndri.arg4val) {}
|
|
inline Function::result_type operator()(Function::second_argument_type a2) const {
|
|
pmf4type pmf = reinterpret_cast<pmf4type>(pmf0);
|
|
return (objval.*pmf)(arg1val, a2, arg3val, arg4val);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::argument_3_type arg3val;
|
|
Function::argument_4_type arg4val;
|
|
};
|
|
|
|
template<class Function> class std_bndr_const_obj_1_2_4 :
|
|
public std_arity1opmf_const<Function>,
|
|
private std_arity4_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type> {
|
|
public:
|
|
explicit inline std_bndr_const_obj_1_2_4(const Function::object_type& oi, const Function &f, Function::first_argument_type a1, Function::second_argument_type a2, Function::argument_4_type a4) :
|
|
std_arity1opmf_const<Function>(oi, reinterpret_cast<pmf1type>(f.pmf0)), std_arity4_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type>(f), arg1val(a1), arg2val(a2), arg4val(a4) {}
|
|
inline std_bndr_const_obj_1_2_4(const std_bndr_const_obj_1_2_4& bndri) :
|
|
std_arity1opmf_const<Function>(bndri.objval, reinterpret_cast<pmf1type>(bndri.pmf0)), std_arity4_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type, Function::result_type>(bndri), arg1val(bndri.arg1val), arg2val(bndri.arg2val), arg4val(bndri.arg4val) {}
|
|
inline Function::result_type operator()(Function::argument_3_type a3) const {
|
|
pmf4type pmf = reinterpret_cast<pmf4type>(pmf0);
|
|
return (objval.*pmf)(arg1val, arg2val, a3, arg4val);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::second_argument_type arg2val;
|
|
Function::argument_4_type arg4val;
|
|
};
|
|
|
|
|
|
|
|
// Template Functions for binding arity 4 to arity 1
|
|
|
|
|
|
// Template Functions for binding pmf of arity 4 to arity 1
|
|
|
|
template<class Function, class A2,
|
|
class A3,
|
|
class A4> inline std_bndr_mf_2_3_4<Function>
|
|
std_bind_mf_2_3_4(const Function &f, A2 a2,
|
|
A3 a3,
|
|
A4 a4) {
|
|
return std_bndr_mf_2_3_4<Function>(f, Function::second_argument_type(a2), Function::argument_3_type(a3), Function::argument_4_type(a4));
|
|
};
|
|
|
|
template<class Function, class A1,
|
|
class A3,
|
|
class A4> inline std_bndr_mf_1_3_4<Function>
|
|
std_bind_mf_1_3_4(const Function &f, A1 a1,
|
|
A3 a3,
|
|
A4 a4) {
|
|
return std_bndr_mf_1_3_4<Function>(f, Function::first_argument_type(a1), Function::argument_3_type(a3), Function::argument_4_type(a4));
|
|
};
|
|
|
|
template<class Function, class A1,
|
|
class A2,
|
|
class A4> inline std_bndr_mf_1_2_4<Function>
|
|
std_bind_mf_1_2_4(const Function &f, A1 a1,
|
|
A2 a2,
|
|
A4 a4) {
|
|
return std_bndr_mf_1_2_4<Function>(f, Function::first_argument_type(a1), Function::second_argument_type(a2), Function::argument_4_type(a4));
|
|
};
|
|
|
|
|
|
|
|
// Template Functions for binding const pmf of arity 4 to arity 1
|
|
|
|
template<class Function, class A2,
|
|
class A3,
|
|
class A4> inline std_bndr_const_mf_2_3_4<Function>
|
|
std_bind_const_mf_2_3_4(const Function &f, A2 a2,
|
|
A3 a3,
|
|
A4 a4) {
|
|
return std_bndr_const_mf_2_3_4<Function>(f, Function::second_argument_type(a2), Function::argument_3_type(a3), Function::argument_4_type(a4));
|
|
};
|
|
|
|
template<class Function, class A1,
|
|
class A3,
|
|
class A4> inline std_bndr_const_mf_1_3_4<Function>
|
|
std_bind_const_mf_1_3_4(const Function &f, A1 a1,
|
|
A3 a3,
|
|
A4 a4) {
|
|
return std_bndr_const_mf_1_3_4<Function>(f, Function::first_argument_type(a1), Function::argument_3_type(a3), Function::argument_4_type(a4));
|
|
};
|
|
|
|
template<class Function, class A1,
|
|
class A2,
|
|
class A4> inline std_bndr_const_mf_1_2_4<Function>
|
|
std_bind_const_mf_1_2_4(const Function &f, A1 a1,
|
|
A2 a2,
|
|
A4 a4) {
|
|
return std_bndr_const_mf_1_2_4<Function>(f, Function::first_argument_type(a1), Function::second_argument_type(a2), Function::argument_4_type(a4));
|
|
};
|
|
|
|
|
|
|
|
// Template Functions for binding obj&pmf Ref of arity 4 to arity 1
|
|
|
|
template<class Function, class Object,
|
|
class A2,
|
|
class A3,
|
|
class A4> inline std_bndr_obj_2_3_4<Function>
|
|
std_bind_obj_2_3_4(Object& oi, const Function &f, A2 a2,
|
|
A3 a3,
|
|
A4 a4) {
|
|
return std_bndr_obj_2_3_4<Function>(static_cast<Function::object_type&>(oi), f, Function::second_argument_type(a2), Function::argument_3_type(a3), Function::argument_4_type(a4));
|
|
};
|
|
|
|
template<class Function, class Object,
|
|
class A1,
|
|
class A3,
|
|
class A4> inline std_bndr_obj_1_3_4<Function>
|
|
std_bind_obj_1_3_4(Object& oi, const Function &f, A1 a1,
|
|
A3 a3,
|
|
A4 a4) {
|
|
return std_bndr_obj_1_3_4<Function>(static_cast<Function::object_type&>(oi), f, Function::first_argument_type(a1), Function::argument_3_type(a3), Function::argument_4_type(a4));
|
|
};
|
|
|
|
template<class Function, class Object,
|
|
class A1,
|
|
class A2,
|
|
class A4> inline std_bndr_obj_1_2_4<Function>
|
|
std_bind_obj_1_2_4(Object& oi, const Function &f, A1 a1,
|
|
A2 a2,
|
|
A4 a4) {
|
|
return std_bndr_obj_1_2_4<Function>(static_cast<Function::object_type&>(oi), f, Function::first_argument_type(a1), Function::second_argument_type(a2), Function::argument_4_type(a4));
|
|
};
|
|
|
|
|
|
|
|
// Template Functions for binding const obj&pmf Ref of arity 4 to arity 1
|
|
|
|
template<class Function, const class Object,
|
|
class A2,
|
|
class A3,
|
|
class A4> inline std_bndr_const_obj_2_3_4<Function>
|
|
std_bind_const_obj_2_3_4(const Object& oi, const Function &f, A2 a2,
|
|
A3 a3,
|
|
A4 a4) {
|
|
return std_bndr_const_obj_2_3_4<Function>(static_cast<Function::object_type&>(oi), f, Function::second_argument_type(a2), Function::argument_3_type(a3), Function::argument_4_type(a4));
|
|
};
|
|
|
|
template<class Function, const class Object,
|
|
class A1,
|
|
class A3,
|
|
class A4> inline std_bndr_const_obj_1_3_4<Function>
|
|
std_bind_const_obj_1_3_4(const Object& oi, const Function &f, A1 a1,
|
|
A3 a3,
|
|
A4 a4) {
|
|
return std_bndr_const_obj_1_3_4<Function>(static_cast<Function::object_type&>(oi), f, Function::first_argument_type(a1), Function::argument_3_type(a3), Function::argument_4_type(a4));
|
|
};
|
|
|
|
template<class Function, const class Object,
|
|
class A1,
|
|
class A2,
|
|
class A4> inline std_bndr_const_obj_1_2_4<Function>
|
|
std_bind_const_obj_1_2_4(const Object& oi, const Function &f, A1 a1,
|
|
A2 a2,
|
|
A4 a4) {
|
|
return std_bndr_const_obj_1_2_4<Function>(static_cast<Function::object_type&>(oi), f, Function::first_argument_type(a1), Function::second_argument_type(a2), Function::argument_4_type(a4));
|
|
};
|
|
|
|
|
|
|
|
//
|
|
// binders for arity 5
|
|
//
|
|
|
|
|
|
// Template Classes for binding arity 5 to arity 1
|
|
|
|
|
|
// Template Classes for binding pmf of arity 5 to arity 1
|
|
|
|
template<class Function> class std_bndr_mf_2_3_4_5 :
|
|
public std_arity1pmf<Function::object_type, Function::first_argument_type, Function::result_type>,
|
|
private std_arity5_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type> {
|
|
public:
|
|
explicit inline std_bndr_mf_2_3_4_5(const Function &f, Function::second_argument_type a2, Function::argument_3_type a3, Function::argument_4_type a4, Function::argument_5_type a5) :
|
|
std_arity1pmf<Function::object_type, Function::first_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(f.pmf0)), std_arity5_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type>(f), arg2val(a2), arg3val(a3), arg4val(a4), arg5val(a5) {}
|
|
inline std_bndr_mf_2_3_4_5(const std_bndr_mf_2_3_4_5& bndri) :
|
|
std_arity1pmf<Function::object_type, Function::first_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(bndri.pmf0)), std_arity5_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type>(bndri), arg2val(bndri.arg2val), arg3val(bndri.arg3val), arg4val(bndri.arg4val), arg5val(bndri.arg5val) {}
|
|
inline virtual Function::result_type operator()(Function::object_type& o, Function::first_argument_type a1) const {
|
|
pmf5type pmf = reinterpret_cast<pmf5type>(pmf0);
|
|
return (o.*pmf)(a1, arg2val, arg3val, arg4val, arg5val);
|
|
}
|
|
public:
|
|
Function::second_argument_type arg2val;
|
|
Function::argument_3_type arg3val;
|
|
Function::argument_4_type arg4val;
|
|
Function::argument_5_type arg5val;
|
|
};
|
|
|
|
template<class Function> class std_bndr_mf_1_3_4_5 :
|
|
public std_arity1pmf<Function::object_type, Function::second_argument_type, Function::result_type>,
|
|
private std_arity5_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type> {
|
|
public:
|
|
explicit inline std_bndr_mf_1_3_4_5(const Function &f, Function::first_argument_type a1, Function::argument_3_type a3, Function::argument_4_type a4, Function::argument_5_type a5) :
|
|
std_arity1pmf<Function::object_type, Function::second_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(f.pmf0)), std_arity5_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type>(f), arg1val(a1), arg3val(a3), arg4val(a4), arg5val(a5) {}
|
|
inline std_bndr_mf_1_3_4_5(const std_bndr_mf_1_3_4_5& bndri) :
|
|
std_arity1pmf<Function::object_type, Function::second_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(bndri.pmf0)), std_arity5_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type>(bndri), arg1val(bndri.arg1val), arg3val(bndri.arg3val), arg4val(bndri.arg4val), arg5val(bndri.arg5val) {}
|
|
inline virtual Function::result_type operator()(Function::object_type& o, Function::second_argument_type a2) const {
|
|
pmf5type pmf = reinterpret_cast<pmf5type>(pmf0);
|
|
return (o.*pmf)(arg1val, a2, arg3val, arg4val, arg5val);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::argument_3_type arg3val;
|
|
Function::argument_4_type arg4val;
|
|
Function::argument_5_type arg5val;
|
|
};
|
|
|
|
template<class Function> class std_bndr_mf_1_2_4_5 :
|
|
public std_arity1pmf<Function::object_type, Function::argument_3_type, Function::result_type>,
|
|
private std_arity5_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type> {
|
|
public:
|
|
explicit inline std_bndr_mf_1_2_4_5(const Function &f, Function::first_argument_type a1, Function::second_argument_type a2, Function::argument_4_type a4, Function::argument_5_type a5) :
|
|
std_arity1pmf<Function::object_type, Function::argument_3_type, Function::result_type>(reinterpret_cast<pmf1type>(f.pmf0)), std_arity5_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type>(f), arg1val(a1), arg2val(a2), arg4val(a4), arg5val(a5) {}
|
|
inline std_bndr_mf_1_2_4_5(const std_bndr_mf_1_2_4_5& bndri) :
|
|
std_arity1pmf<Function::object_type, Function::argument_3_type, Function::result_type>(reinterpret_cast<pmf1type>(bndri.pmf0)), std_arity5_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type>(bndri), arg1val(bndri.arg1val), arg2val(bndri.arg2val), arg4val(bndri.arg4val), arg5val(bndri.arg5val) {}
|
|
inline virtual Function::result_type operator()(Function::object_type& o, Function::argument_3_type a3) const {
|
|
pmf5type pmf = reinterpret_cast<pmf5type>(pmf0);
|
|
return (o.*pmf)(arg1val, arg2val, a3, arg4val, arg5val);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::second_argument_type arg2val;
|
|
Function::argument_4_type arg4val;
|
|
Function::argument_5_type arg5val;
|
|
};
|
|
|
|
|
|
|
|
// Template Classes for binding const pmf of arity 5 to arity 1
|
|
|
|
template<class Function> class std_bndr_const_mf_2_3_4_5 :
|
|
public std_arity1pmf_const<Function::object_type, Function::first_argument_type, Function::result_type>,
|
|
private std_arity5_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type> {
|
|
public:
|
|
explicit inline std_bndr_const_mf_2_3_4_5(const Function &f, Function::second_argument_type a2, Function::argument_3_type a3, Function::argument_4_type a4, Function::argument_5_type a5) :
|
|
std_arity1pmf_const<Function::object_type, Function::first_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(f.pmf0)), std_arity5_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type>(f), arg2val(a2), arg3val(a3), arg4val(a4), arg5val(a5) {}
|
|
inline std_bndr_const_mf_2_3_4_5(const std_bndr_const_mf_2_3_4_5& bndri) :
|
|
std_arity1pmf_const<Function::object_type, Function::first_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(bndri.pmf0)), std_arity5_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type>(bndri), arg2val(bndri.arg2val), arg3val(bndri.arg3val), arg4val(bndri.arg4val), arg5val(bndri.arg5val) {}
|
|
inline virtual Function::result_type operator()(Function::object_type& o, Function::first_argument_type a1) const {
|
|
pmf5type pmf = reinterpret_cast<pmf5type>(pmf0);
|
|
return (o.*pmf)(a1, arg2val, arg3val, arg4val, arg5val);
|
|
}
|
|
public:
|
|
Function::second_argument_type arg2val;
|
|
Function::argument_3_type arg3val;
|
|
Function::argument_4_type arg4val;
|
|
Function::argument_5_type arg5val;
|
|
};
|
|
|
|
template<class Function> class std_bndr_const_mf_1_3_4_5 :
|
|
public std_arity1pmf_const<Function::object_type, Function::second_argument_type, Function::result_type>,
|
|
private std_arity5_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type> {
|
|
public:
|
|
explicit inline std_bndr_const_mf_1_3_4_5(const Function &f, Function::first_argument_type a1, Function::argument_3_type a3, Function::argument_4_type a4, Function::argument_5_type a5) :
|
|
std_arity1pmf_const<Function::object_type, Function::second_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(f.pmf0)), std_arity5_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type>(f), arg1val(a1), arg3val(a3), arg4val(a4), arg5val(a5) {}
|
|
inline std_bndr_const_mf_1_3_4_5(const std_bndr_const_mf_1_3_4_5& bndri) :
|
|
std_arity1pmf_const<Function::object_type, Function::second_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(bndri.pmf0)), std_arity5_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type>(bndri), arg1val(bndri.arg1val), arg3val(bndri.arg3val), arg4val(bndri.arg4val), arg5val(bndri.arg5val) {}
|
|
inline virtual Function::result_type operator()(Function::object_type& o, Function::second_argument_type a2) const {
|
|
pmf5type pmf = reinterpret_cast<pmf5type>(pmf0);
|
|
return (o.*pmf)(arg1val, a2, arg3val, arg4val, arg5val);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::argument_3_type arg3val;
|
|
Function::argument_4_type arg4val;
|
|
Function::argument_5_type arg5val;
|
|
};
|
|
|
|
template<class Function> class std_bndr_const_mf_1_2_4_5 :
|
|
public std_arity1pmf_const<Function::object_type, Function::argument_3_type, Function::result_type>,
|
|
private std_arity5_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type> {
|
|
public:
|
|
explicit inline std_bndr_const_mf_1_2_4_5(const Function &f, Function::first_argument_type a1, Function::second_argument_type a2, Function::argument_4_type a4, Function::argument_5_type a5) :
|
|
std_arity1pmf_const<Function::object_type, Function::argument_3_type, Function::result_type>(reinterpret_cast<pmf1type>(f.pmf0)), std_arity5_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type>(f), arg1val(a1), arg2val(a2), arg4val(a4), arg5val(a5) {}
|
|
inline std_bndr_const_mf_1_2_4_5(const std_bndr_const_mf_1_2_4_5& bndri) :
|
|
std_arity1pmf_const<Function::object_type, Function::argument_3_type, Function::result_type>(reinterpret_cast<pmf1type>(bndri.pmf0)), std_arity5_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type>(bndri), arg1val(bndri.arg1val), arg2val(bndri.arg2val), arg4val(bndri.arg4val), arg5val(bndri.arg5val) {}
|
|
inline virtual Function::result_type operator()(Function::object_type& o, Function::argument_3_type a3) const {
|
|
pmf5type pmf = reinterpret_cast<pmf5type>(pmf0);
|
|
return (o.*pmf)(arg1val, arg2val, a3, arg4val, arg5val);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::second_argument_type arg2val;
|
|
Function::argument_4_type arg4val;
|
|
Function::argument_5_type arg5val;
|
|
};
|
|
|
|
|
|
|
|
// Template Classes for binding obj&pmf Ref of arity 5 to arity 1
|
|
|
|
template<class Function> class std_bndr_obj_2_3_4_5 :
|
|
public std_arity1opmf<Function>,
|
|
private std_arity5_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type> {
|
|
public:
|
|
explicit inline std_bndr_obj_2_3_4_5(Function::object_type& oi, const Function &f, Function::second_argument_type a2, Function::argument_3_type a3, Function::argument_4_type a4, Function::argument_5_type a5) :
|
|
std_arity1opmf<Function>(oi, reinterpret_cast<pmf1type>(f.pmf0)), std_arity5_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type>(f), arg2val(a2), arg3val(a3), arg4val(a4), arg5val(a5) {}
|
|
inline std_bndr_obj_2_3_4_5(const std_bndr_obj_2_3_4_5& bndri) :
|
|
std_arity1opmf<Function>(bndri.objval, reinterpret_cast<pmf1type>(bndri.pmf0)), std_arity5_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type>(bndri), arg2val(bndri.arg2val), arg3val(bndri.arg3val), arg4val(bndri.arg4val), arg5val(bndri.arg5val) {}
|
|
inline Function::result_type operator()(Function::first_argument_type a1) const {
|
|
pmf5type pmf = reinterpret_cast<pmf5type>(pmf0);
|
|
return (objval.*pmf)(a1, arg2val, arg3val, arg4val, arg5val);
|
|
}
|
|
public:
|
|
Function::second_argument_type arg2val;
|
|
Function::argument_3_type arg3val;
|
|
Function::argument_4_type arg4val;
|
|
Function::argument_5_type arg5val;
|
|
};
|
|
|
|
template<class Function> class std_bndr_obj_1_3_4_5 :
|
|
public std_arity1opmf<Function>,
|
|
private std_arity5_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type> {
|
|
public:
|
|
explicit inline std_bndr_obj_1_3_4_5(Function::object_type& oi, const Function &f, Function::first_argument_type a1, Function::argument_3_type a3, Function::argument_4_type a4, Function::argument_5_type a5) :
|
|
std_arity1opmf<Function>(oi, reinterpret_cast<pmf1type>(f.pmf0)), std_arity5_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type>(f), arg1val(a1), arg3val(a3), arg4val(a4), arg5val(a5) {}
|
|
inline std_bndr_obj_1_3_4_5(const std_bndr_obj_1_3_4_5& bndri) :
|
|
std_arity1opmf<Function>(bndri.objval, reinterpret_cast<pmf1type>(bndri.pmf0)), std_arity5_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type>(bndri), arg1val(bndri.arg1val), arg3val(bndri.arg3val), arg4val(bndri.arg4val), arg5val(bndri.arg5val) {}
|
|
inline Function::result_type operator()(Function::second_argument_type a2) const {
|
|
pmf5type pmf = reinterpret_cast<pmf5type>(pmf0);
|
|
return (objval.*pmf)(arg1val, a2, arg3val, arg4val, arg5val);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::argument_3_type arg3val;
|
|
Function::argument_4_type arg4val;
|
|
Function::argument_5_type arg5val;
|
|
};
|
|
|
|
template<class Function> class std_bndr_obj_1_2_4_5 :
|
|
public std_arity1opmf<Function>,
|
|
private std_arity5_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type> {
|
|
public:
|
|
explicit inline std_bndr_obj_1_2_4_5(Function::object_type& oi, const Function &f, Function::first_argument_type a1, Function::second_argument_type a2, Function::argument_4_type a4, Function::argument_5_type a5) :
|
|
std_arity1opmf<Function>(oi, reinterpret_cast<pmf1type>(f.pmf0)), std_arity5_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type>(f), arg1val(a1), arg2val(a2), arg4val(a4), arg5val(a5) {}
|
|
inline std_bndr_obj_1_2_4_5(const std_bndr_obj_1_2_4_5& bndri) :
|
|
std_arity1opmf<Function>(bndri.objval, reinterpret_cast<pmf1type>(bndri.pmf0)), std_arity5_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type>(bndri), arg1val(bndri.arg1val), arg2val(bndri.arg2val), arg4val(bndri.arg4val), arg5val(bndri.arg5val) {}
|
|
inline Function::result_type operator()(Function::argument_3_type a3) const {
|
|
pmf5type pmf = reinterpret_cast<pmf5type>(pmf0);
|
|
return (objval.*pmf)(arg1val, arg2val, a3, arg4val, arg5val);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::second_argument_type arg2val;
|
|
Function::argument_4_type arg4val;
|
|
Function::argument_5_type arg5val;
|
|
};
|
|
|
|
|
|
|
|
// Template Classes for binding const obj&pmf Ref of arity 5 to arity 1
|
|
|
|
template<class Function> class std_bndr_const_obj_2_3_4_5 :
|
|
public std_arity1opmf_const<Function>,
|
|
private std_arity5_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type> {
|
|
public:
|
|
explicit inline std_bndr_const_obj_2_3_4_5(const Function::object_type& oi, const Function &f, Function::second_argument_type a2, Function::argument_3_type a3, Function::argument_4_type a4, Function::argument_5_type a5) :
|
|
std_arity1opmf_const<Function>(oi, reinterpret_cast<pmf1type>(f.pmf0)), std_arity5_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type>(f), arg2val(a2), arg3val(a3), arg4val(a4), arg5val(a5) {}
|
|
inline std_bndr_const_obj_2_3_4_5(const std_bndr_const_obj_2_3_4_5& bndri) :
|
|
std_arity1opmf_const<Function>(bndri.objval, reinterpret_cast<pmf1type>(bndri.pmf0)), std_arity5_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type>(bndri), arg2val(bndri.arg2val), arg3val(bndri.arg3val), arg4val(bndri.arg4val), arg5val(bndri.arg5val) {}
|
|
inline Function::result_type operator()(Function::first_argument_type a1) const {
|
|
pmf5type pmf = reinterpret_cast<pmf5type>(pmf0);
|
|
return (objval.*pmf)(a1, arg2val, arg3val, arg4val, arg5val);
|
|
}
|
|
public:
|
|
Function::second_argument_type arg2val;
|
|
Function::argument_3_type arg3val;
|
|
Function::argument_4_type arg4val;
|
|
Function::argument_5_type arg5val;
|
|
};
|
|
|
|
template<class Function> class std_bndr_const_obj_1_3_4_5 :
|
|
public std_arity1opmf_const<Function>,
|
|
private std_arity5_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type> {
|
|
public:
|
|
explicit inline std_bndr_const_obj_1_3_4_5(const Function::object_type& oi, const Function &f, Function::first_argument_type a1, Function::argument_3_type a3, Function::argument_4_type a4, Function::argument_5_type a5) :
|
|
std_arity1opmf_const<Function>(oi, reinterpret_cast<pmf1type>(f.pmf0)), std_arity5_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type>(f), arg1val(a1), arg3val(a3), arg4val(a4), arg5val(a5) {}
|
|
inline std_bndr_const_obj_1_3_4_5(const std_bndr_const_obj_1_3_4_5& bndri) :
|
|
std_arity1opmf_const<Function>(bndri.objval, reinterpret_cast<pmf1type>(bndri.pmf0)), std_arity5_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type>(bndri), arg1val(bndri.arg1val), arg3val(bndri.arg3val), arg4val(bndri.arg4val), arg5val(bndri.arg5val) {}
|
|
inline Function::result_type operator()(Function::second_argument_type a2) const {
|
|
pmf5type pmf = reinterpret_cast<pmf5type>(pmf0);
|
|
return (objval.*pmf)(arg1val, a2, arg3val, arg4val, arg5val);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::argument_3_type arg3val;
|
|
Function::argument_4_type arg4val;
|
|
Function::argument_5_type arg5val;
|
|
};
|
|
|
|
template<class Function> class std_bndr_const_obj_1_2_4_5 :
|
|
public std_arity1opmf_const<Function>,
|
|
private std_arity5_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type> {
|
|
public:
|
|
explicit inline std_bndr_const_obj_1_2_4_5(const Function::object_type& oi, const Function &f, Function::first_argument_type a1, Function::second_argument_type a2, Function::argument_4_type a4, Function::argument_5_type a5) :
|
|
std_arity1opmf_const<Function>(oi, reinterpret_cast<pmf1type>(f.pmf0)), std_arity5_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type>(f), arg1val(a1), arg2val(a2), arg4val(a4), arg5val(a5) {}
|
|
inline std_bndr_const_obj_1_2_4_5(const std_bndr_const_obj_1_2_4_5& bndri) :
|
|
std_arity1opmf_const<Function>(bndri.objval, reinterpret_cast<pmf1type>(bndri.pmf0)), std_arity5_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type, Function::result_type>(bndri), arg1val(bndri.arg1val), arg2val(bndri.arg2val), arg4val(bndri.arg4val), arg5val(bndri.arg5val) {}
|
|
inline Function::result_type operator()(Function::argument_3_type a3) const {
|
|
pmf5type pmf = reinterpret_cast<pmf5type>(pmf0);
|
|
return (objval.*pmf)(arg1val, arg2val, a3, arg4val, arg5val);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::second_argument_type arg2val;
|
|
Function::argument_4_type arg4val;
|
|
Function::argument_5_type arg5val;
|
|
};
|
|
|
|
|
|
|
|
// Template Functions for binding arity 5 to arity 1
|
|
|
|
|
|
// Template Functions for binding pmf of arity 5 to arity 1
|
|
|
|
template<class Function, class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5> inline std_bndr_mf_2_3_4_5<Function>
|
|
std_bind_mf_2_3_4_5(const Function &f, A2 a2,
|
|
A3 a3,
|
|
A4 a4,
|
|
A5 a5) {
|
|
return std_bndr_mf_2_3_4_5<Function>(f, Function::second_argument_type(a2), Function::argument_3_type(a3), Function::argument_4_type(a4), Function::argument_5_type(a5));
|
|
};
|
|
|
|
template<class Function, class A1,
|
|
class A3,
|
|
class A4,
|
|
class A5> inline std_bndr_mf_1_3_4_5<Function>
|
|
std_bind_mf_1_3_4_5(const Function &f, A1 a1,
|
|
A3 a3,
|
|
A4 a4,
|
|
A5 a5) {
|
|
return std_bndr_mf_1_3_4_5<Function>(f, Function::first_argument_type(a1), Function::argument_3_type(a3), Function::argument_4_type(a4), Function::argument_5_type(a5));
|
|
};
|
|
|
|
template<class Function, class A1,
|
|
class A2,
|
|
class A4,
|
|
class A5> inline std_bndr_mf_1_2_4_5<Function>
|
|
std_bind_mf_1_2_4_5(const Function &f, A1 a1,
|
|
A2 a2,
|
|
A4 a4,
|
|
A5 a5) {
|
|
return std_bndr_mf_1_2_4_5<Function>(f, Function::first_argument_type(a1), Function::second_argument_type(a2), Function::argument_4_type(a4), Function::argument_5_type(a5));
|
|
};
|
|
|
|
|
|
|
|
// Template Functions for binding const pmf of arity 5 to arity 1
|
|
|
|
template<class Function, class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5> inline std_bndr_const_mf_2_3_4_5<Function>
|
|
std_bind_const_mf_2_3_4_5(const Function &f, A2 a2,
|
|
A3 a3,
|
|
A4 a4,
|
|
A5 a5) {
|
|
return std_bndr_const_mf_2_3_4_5<Function>(f, Function::second_argument_type(a2), Function::argument_3_type(a3), Function::argument_4_type(a4), Function::argument_5_type(a5));
|
|
};
|
|
|
|
template<class Function, class A1,
|
|
class A3,
|
|
class A4,
|
|
class A5> inline std_bndr_const_mf_1_3_4_5<Function>
|
|
std_bind_const_mf_1_3_4_5(const Function &f, A1 a1,
|
|
A3 a3,
|
|
A4 a4,
|
|
A5 a5) {
|
|
return std_bndr_const_mf_1_3_4_5<Function>(f, Function::first_argument_type(a1), Function::argument_3_type(a3), Function::argument_4_type(a4), Function::argument_5_type(a5));
|
|
};
|
|
|
|
template<class Function, class A1,
|
|
class A2,
|
|
class A4,
|
|
class A5> inline std_bndr_const_mf_1_2_4_5<Function>
|
|
std_bind_const_mf_1_2_4_5(const Function &f, A1 a1,
|
|
A2 a2,
|
|
A4 a4,
|
|
A5 a5) {
|
|
return std_bndr_const_mf_1_2_4_5<Function>(f, Function::first_argument_type(a1), Function::second_argument_type(a2), Function::argument_4_type(a4), Function::argument_5_type(a5));
|
|
};
|
|
|
|
|
|
|
|
// Template Functions for binding obj&pmf Ref of arity 5 to arity 1
|
|
|
|
template<class Function, class Object,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5> inline std_bndr_obj_2_3_4_5<Function>
|
|
std_bind_obj_2_3_4_5(Object& oi, const Function &f, A2 a2,
|
|
A3 a3,
|
|
A4 a4,
|
|
A5 a5) {
|
|
return std_bndr_obj_2_3_4_5<Function>(static_cast<Function::object_type&>(oi), f, Function::second_argument_type(a2), Function::argument_3_type(a3), Function::argument_4_type(a4), Function::argument_5_type(a5));
|
|
};
|
|
|
|
template<class Function, class Object,
|
|
class A1,
|
|
class A3,
|
|
class A4,
|
|
class A5> inline std_bndr_obj_1_3_4_5<Function>
|
|
std_bind_obj_1_3_4_5(Object& oi, const Function &f, A1 a1,
|
|
A3 a3,
|
|
A4 a4,
|
|
A5 a5) {
|
|
return std_bndr_obj_1_3_4_5<Function>(static_cast<Function::object_type&>(oi), f, Function::first_argument_type(a1), Function::argument_3_type(a3), Function::argument_4_type(a4), Function::argument_5_type(a5));
|
|
};
|
|
|
|
template<class Function, class Object,
|
|
class A1,
|
|
class A2,
|
|
class A4,
|
|
class A5> inline std_bndr_obj_1_2_4_5<Function>
|
|
std_bind_obj_1_2_4_5(Object& oi, const Function &f, A1 a1,
|
|
A2 a2,
|
|
A4 a4,
|
|
A5 a5) {
|
|
return std_bndr_obj_1_2_4_5<Function>(static_cast<Function::object_type&>(oi), f, Function::first_argument_type(a1), Function::second_argument_type(a2), Function::argument_4_type(a4), Function::argument_5_type(a5));
|
|
};
|
|
|
|
|
|
|
|
// Template Functions for binding const obj&pmf Ref of arity 5 to arity 1
|
|
|
|
template<class Function, const class Object,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5> inline std_bndr_const_obj_2_3_4_5<Function>
|
|
std_bind_const_obj_2_3_4_5(const Object& oi, const Function &f, A2 a2,
|
|
A3 a3,
|
|
A4 a4,
|
|
A5 a5) {
|
|
return std_bndr_const_obj_2_3_4_5<Function>(static_cast<Function::object_type&>(oi), f, Function::second_argument_type(a2), Function::argument_3_type(a3), Function::argument_4_type(a4), Function::argument_5_type(a5));
|
|
};
|
|
|
|
template<class Function, const class Object,
|
|
class A1,
|
|
class A3,
|
|
class A4,
|
|
class A5> inline std_bndr_const_obj_1_3_4_5<Function>
|
|
std_bind_const_obj_1_3_4_5(const Object& oi, const Function &f, A1 a1,
|
|
A3 a3,
|
|
A4 a4,
|
|
A5 a5) {
|
|
return std_bndr_const_obj_1_3_4_5<Function>(static_cast<Function::object_type&>(oi), f, Function::first_argument_type(a1), Function::argument_3_type(a3), Function::argument_4_type(a4), Function::argument_5_type(a5));
|
|
};
|
|
|
|
template<class Function, const class Object,
|
|
class A1,
|
|
class A2,
|
|
class A4,
|
|
class A5> inline std_bndr_const_obj_1_2_4_5<Function>
|
|
std_bind_const_obj_1_2_4_5(const Object& oi, const Function &f, A1 a1,
|
|
A2 a2,
|
|
A4 a4,
|
|
A5 a5) {
|
|
return std_bndr_const_obj_1_2_4_5<Function>(static_cast<Function::object_type&>(oi), f, Function::first_argument_type(a1), Function::second_argument_type(a2), Function::argument_4_type(a4), Function::argument_5_type(a5));
|
|
};
|
|
|
|
|
|
|
|
//
|
|
// binders for arity 6
|
|
//
|
|
|
|
|
|
// Template Classes for binding arity 6 to arity 1
|
|
|
|
|
|
// Template Classes for binding pmf of arity 6 to arity 1
|
|
|
|
template<class Function> class std_bndr_mf_2_3_4_5_6 :
|
|
public std_arity1pmf<Function::object_type, Function::first_argument_type, Function::result_type>,
|
|
private std_arity6_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type> {
|
|
public:
|
|
explicit inline std_bndr_mf_2_3_4_5_6(const Function &f, Function::second_argument_type a2, Function::argument_3_type a3, Function::argument_4_type a4, Function::argument_5_type a5, Function::argument_6_type a6) :
|
|
std_arity1pmf<Function::object_type, Function::first_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(f.pmf0)), std_arity6_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type>(f), arg2val(a2), arg3val(a3), arg4val(a4), arg5val(a5), arg6val(a6) {}
|
|
inline std_bndr_mf_2_3_4_5_6(const std_bndr_mf_2_3_4_5_6& bndri) :
|
|
std_arity1pmf<Function::object_type, Function::first_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(bndri.pmf0)), std_arity6_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type>(bndri), arg2val(bndri.arg2val), arg3val(bndri.arg3val), arg4val(bndri.arg4val), arg5val(bndri.arg5val), arg6val(bndri.arg6val) {}
|
|
inline virtual Function::result_type operator()(Function::object_type& o, Function::first_argument_type a1) const {
|
|
pmf6type pmf = reinterpret_cast<pmf6type>(pmf0);
|
|
return (o.*pmf)(a1, arg2val, arg3val, arg4val, arg5val, arg6val);
|
|
}
|
|
public:
|
|
Function::second_argument_type arg2val;
|
|
Function::argument_3_type arg3val;
|
|
Function::argument_4_type arg4val;
|
|
Function::argument_5_type arg5val;
|
|
Function::argument_6_type arg6val;
|
|
};
|
|
|
|
template<class Function> class std_bndr_mf_1_3_4_5_6 :
|
|
public std_arity1pmf<Function::object_type, Function::second_argument_type, Function::result_type>,
|
|
private std_arity6_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type> {
|
|
public:
|
|
explicit inline std_bndr_mf_1_3_4_5_6(const Function &f, Function::first_argument_type a1, Function::argument_3_type a3, Function::argument_4_type a4, Function::argument_5_type a5, Function::argument_6_type a6) :
|
|
std_arity1pmf<Function::object_type, Function::second_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(f.pmf0)), std_arity6_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type>(f), arg1val(a1), arg3val(a3), arg4val(a4), arg5val(a5), arg6val(a6) {}
|
|
inline std_bndr_mf_1_3_4_5_6(const std_bndr_mf_1_3_4_5_6& bndri) :
|
|
std_arity1pmf<Function::object_type, Function::second_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(bndri.pmf0)), std_arity6_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type>(bndri), arg1val(bndri.arg1val), arg3val(bndri.arg3val), arg4val(bndri.arg4val), arg5val(bndri.arg5val), arg6val(bndri.arg6val) {}
|
|
inline virtual Function::result_type operator()(Function::object_type& o, Function::second_argument_type a2) const {
|
|
pmf6type pmf = reinterpret_cast<pmf6type>(pmf0);
|
|
return (o.*pmf)(arg1val, a2, arg3val, arg4val, arg5val, arg6val);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::argument_3_type arg3val;
|
|
Function::argument_4_type arg4val;
|
|
Function::argument_5_type arg5val;
|
|
Function::argument_6_type arg6val;
|
|
};
|
|
|
|
template<class Function> class std_bndr_mf_1_2_4_5_6 :
|
|
public std_arity1pmf<Function::object_type, Function::argument_3_type, Function::result_type>,
|
|
private std_arity6_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type> {
|
|
public:
|
|
explicit inline std_bndr_mf_1_2_4_5_6(const Function &f, Function::first_argument_type a1, Function::second_argument_type a2, Function::argument_4_type a4, Function::argument_5_type a5, Function::argument_6_type a6) :
|
|
std_arity1pmf<Function::object_type, Function::argument_3_type, Function::result_type>(reinterpret_cast<pmf1type>(f.pmf0)), std_arity6_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type>(f), arg1val(a1), arg2val(a2), arg4val(a4), arg5val(a5), arg6val(a6) {}
|
|
inline std_bndr_mf_1_2_4_5_6(const std_bndr_mf_1_2_4_5_6& bndri) :
|
|
std_arity1pmf<Function::object_type, Function::argument_3_type, Function::result_type>(reinterpret_cast<pmf1type>(bndri.pmf0)), std_arity6_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type>(bndri), arg1val(bndri.arg1val), arg2val(bndri.arg2val), arg4val(bndri.arg4val), arg5val(bndri.arg5val), arg6val(bndri.arg6val) {}
|
|
inline virtual Function::result_type operator()(Function::object_type& o, Function::argument_3_type a3) const {
|
|
pmf6type pmf = reinterpret_cast<pmf6type>(pmf0);
|
|
return (o.*pmf)(arg1val, arg2val, a3, arg4val, arg5val, arg6val);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::second_argument_type arg2val;
|
|
Function::argument_4_type arg4val;
|
|
Function::argument_5_type arg5val;
|
|
Function::argument_6_type arg6val;
|
|
};
|
|
|
|
|
|
|
|
// Template Classes for binding const pmf of arity 6 to arity 1
|
|
|
|
template<class Function> class std_bndr_const_mf_2_3_4_5_6 :
|
|
public std_arity1pmf_const<Function::object_type, Function::first_argument_type, Function::result_type>,
|
|
private std_arity6_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type> {
|
|
public:
|
|
explicit inline std_bndr_const_mf_2_3_4_5_6(const Function &f, Function::second_argument_type a2, Function::argument_3_type a3, Function::argument_4_type a4, Function::argument_5_type a5, Function::argument_6_type a6) :
|
|
std_arity1pmf_const<Function::object_type, Function::first_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(f.pmf0)), std_arity6_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type>(f), arg2val(a2), arg3val(a3), arg4val(a4), arg5val(a5), arg6val(a6) {}
|
|
inline std_bndr_const_mf_2_3_4_5_6(const std_bndr_const_mf_2_3_4_5_6& bndri) :
|
|
std_arity1pmf_const<Function::object_type, Function::first_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(bndri.pmf0)), std_arity6_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type>(bndri), arg2val(bndri.arg2val), arg3val(bndri.arg3val), arg4val(bndri.arg4val), arg5val(bndri.arg5val), arg6val(bndri.arg6val) {}
|
|
inline virtual Function::result_type operator()(Function::object_type& o, Function::first_argument_type a1) const {
|
|
pmf6type pmf = reinterpret_cast<pmf6type>(pmf0);
|
|
return (o.*pmf)(a1, arg2val, arg3val, arg4val, arg5val, arg6val);
|
|
}
|
|
public:
|
|
Function::second_argument_type arg2val;
|
|
Function::argument_3_type arg3val;
|
|
Function::argument_4_type arg4val;
|
|
Function::argument_5_type arg5val;
|
|
Function::argument_6_type arg6val;
|
|
};
|
|
|
|
template<class Function> class std_bndr_const_mf_1_3_4_5_6 :
|
|
public std_arity1pmf_const<Function::object_type, Function::second_argument_type, Function::result_type>,
|
|
private std_arity6_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type> {
|
|
public:
|
|
explicit inline std_bndr_const_mf_1_3_4_5_6(const Function &f, Function::first_argument_type a1, Function::argument_3_type a3, Function::argument_4_type a4, Function::argument_5_type a5, Function::argument_6_type a6) :
|
|
std_arity1pmf_const<Function::object_type, Function::second_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(f.pmf0)), std_arity6_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type>(f), arg1val(a1), arg3val(a3), arg4val(a4), arg5val(a5), arg6val(a6) {}
|
|
inline std_bndr_const_mf_1_3_4_5_6(const std_bndr_const_mf_1_3_4_5_6& bndri) :
|
|
std_arity1pmf_const<Function::object_type, Function::second_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(bndri.pmf0)), std_arity6_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type>(bndri), arg1val(bndri.arg1val), arg3val(bndri.arg3val), arg4val(bndri.arg4val), arg5val(bndri.arg5val), arg6val(bndri.arg6val) {}
|
|
inline virtual Function::result_type operator()(Function::object_type& o, Function::second_argument_type a2) const {
|
|
pmf6type pmf = reinterpret_cast<pmf6type>(pmf0);
|
|
return (o.*pmf)(arg1val, a2, arg3val, arg4val, arg5val, arg6val);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::argument_3_type arg3val;
|
|
Function::argument_4_type arg4val;
|
|
Function::argument_5_type arg5val;
|
|
Function::argument_6_type arg6val;
|
|
};
|
|
|
|
template<class Function> class std_bndr_const_mf_1_2_4_5_6 :
|
|
public std_arity1pmf_const<Function::object_type, Function::argument_3_type, Function::result_type>,
|
|
private std_arity6_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type> {
|
|
public:
|
|
explicit inline std_bndr_const_mf_1_2_4_5_6(const Function &f, Function::first_argument_type a1, Function::second_argument_type a2, Function::argument_4_type a4, Function::argument_5_type a5, Function::argument_6_type a6) :
|
|
std_arity1pmf_const<Function::object_type, Function::argument_3_type, Function::result_type>(reinterpret_cast<pmf1type>(f.pmf0)), std_arity6_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type>(f), arg1val(a1), arg2val(a2), arg4val(a4), arg5val(a5), arg6val(a6) {}
|
|
inline std_bndr_const_mf_1_2_4_5_6(const std_bndr_const_mf_1_2_4_5_6& bndri) :
|
|
std_arity1pmf_const<Function::object_type, Function::argument_3_type, Function::result_type>(reinterpret_cast<pmf1type>(bndri.pmf0)), std_arity6_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type>(bndri), arg1val(bndri.arg1val), arg2val(bndri.arg2val), arg4val(bndri.arg4val), arg5val(bndri.arg5val), arg6val(bndri.arg6val) {}
|
|
inline virtual Function::result_type operator()(Function::object_type& o, Function::argument_3_type a3) const {
|
|
pmf6type pmf = reinterpret_cast<pmf6type>(pmf0);
|
|
return (o.*pmf)(arg1val, arg2val, a3, arg4val, arg5val, arg6val);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::second_argument_type arg2val;
|
|
Function::argument_4_type arg4val;
|
|
Function::argument_5_type arg5val;
|
|
Function::argument_6_type arg6val;
|
|
};
|
|
|
|
|
|
|
|
// Template Classes for binding obj&pmf Ref of arity 6 to arity 1
|
|
|
|
template<class Function> class std_bndr_obj_2_3_4_5_6 :
|
|
public std_arity1opmf<Function>,
|
|
private std_arity6_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type> {
|
|
public:
|
|
explicit inline std_bndr_obj_2_3_4_5_6(Function::object_type& oi, const Function &f, Function::second_argument_type a2, Function::argument_3_type a3, Function::argument_4_type a4, Function::argument_5_type a5, Function::argument_6_type a6) :
|
|
std_arity1opmf<Function>(oi, reinterpret_cast<pmf1type>(f.pmf0)), std_arity6_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type>(f), arg2val(a2), arg3val(a3), arg4val(a4), arg5val(a5), arg6val(a6) {}
|
|
inline std_bndr_obj_2_3_4_5_6(const std_bndr_obj_2_3_4_5_6& bndri) :
|
|
std_arity1opmf<Function>(bndri.objval, reinterpret_cast<pmf1type>(bndri.pmf0)), std_arity6_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type>(bndri), arg2val(bndri.arg2val), arg3val(bndri.arg3val), arg4val(bndri.arg4val), arg5val(bndri.arg5val), arg6val(bndri.arg6val) {}
|
|
inline Function::result_type operator()(Function::first_argument_type a1) const {
|
|
pmf6type pmf = reinterpret_cast<pmf6type>(pmf0);
|
|
return (objval.*pmf)(a1, arg2val, arg3val, arg4val, arg5val, arg6val);
|
|
}
|
|
public:
|
|
Function::second_argument_type arg2val;
|
|
Function::argument_3_type arg3val;
|
|
Function::argument_4_type arg4val;
|
|
Function::argument_5_type arg5val;
|
|
Function::argument_6_type arg6val;
|
|
};
|
|
|
|
template<class Function> class std_bndr_obj_1_3_4_5_6 :
|
|
public std_arity1opmf<Function>,
|
|
private std_arity6_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type> {
|
|
public:
|
|
explicit inline std_bndr_obj_1_3_4_5_6(Function::object_type& oi, const Function &f, Function::first_argument_type a1, Function::argument_3_type a3, Function::argument_4_type a4, Function::argument_5_type a5, Function::argument_6_type a6) :
|
|
std_arity1opmf<Function>(oi, reinterpret_cast<pmf1type>(f.pmf0)), std_arity6_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type>(f), arg1val(a1), arg3val(a3), arg4val(a4), arg5val(a5), arg6val(a6) {}
|
|
inline std_bndr_obj_1_3_4_5_6(const std_bndr_obj_1_3_4_5_6& bndri) :
|
|
std_arity1opmf<Function>(bndri.objval, reinterpret_cast<pmf1type>(bndri.pmf0)), std_arity6_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type>(bndri), arg1val(bndri.arg1val), arg3val(bndri.arg3val), arg4val(bndri.arg4val), arg5val(bndri.arg5val), arg6val(bndri.arg6val) {}
|
|
inline Function::result_type operator()(Function::second_argument_type a2) const {
|
|
pmf6type pmf = reinterpret_cast<pmf6type>(pmf0);
|
|
return (objval.*pmf)(arg1val, a2, arg3val, arg4val, arg5val, arg6val);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::argument_3_type arg3val;
|
|
Function::argument_4_type arg4val;
|
|
Function::argument_5_type arg5val;
|
|
Function::argument_6_type arg6val;
|
|
};
|
|
|
|
template<class Function> class std_bndr_obj_1_2_4_5_6 :
|
|
public std_arity1opmf<Function>,
|
|
private std_arity6_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type> {
|
|
public:
|
|
explicit inline std_bndr_obj_1_2_4_5_6(Function::object_type& oi, const Function &f, Function::first_argument_type a1, Function::second_argument_type a2, Function::argument_4_type a4, Function::argument_5_type a5, Function::argument_6_type a6) :
|
|
std_arity1opmf<Function>(oi, reinterpret_cast<pmf1type>(f.pmf0)), std_arity6_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type>(f), arg1val(a1), arg2val(a2), arg4val(a4), arg5val(a5), arg6val(a6) {}
|
|
inline std_bndr_obj_1_2_4_5_6(const std_bndr_obj_1_2_4_5_6& bndri) :
|
|
std_arity1opmf<Function>(bndri.objval, reinterpret_cast<pmf1type>(bndri.pmf0)), std_arity6_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type>(bndri), arg1val(bndri.arg1val), arg2val(bndri.arg2val), arg4val(bndri.arg4val), arg5val(bndri.arg5val), arg6val(bndri.arg6val) {}
|
|
inline Function::result_type operator()(Function::argument_3_type a3) const {
|
|
pmf6type pmf = reinterpret_cast<pmf6type>(pmf0);
|
|
return (objval.*pmf)(arg1val, arg2val, a3, arg4val, arg5val, arg6val);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::second_argument_type arg2val;
|
|
Function::argument_4_type arg4val;
|
|
Function::argument_5_type arg5val;
|
|
Function::argument_6_type arg6val;
|
|
};
|
|
|
|
|
|
|
|
// Template Classes for binding const obj&pmf Ref of arity 6 to arity 1
|
|
|
|
template<class Function> class std_bndr_const_obj_2_3_4_5_6 :
|
|
public std_arity1opmf_const<Function>,
|
|
private std_arity6_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type> {
|
|
public:
|
|
explicit inline std_bndr_const_obj_2_3_4_5_6(const Function::object_type& oi, const Function &f, Function::second_argument_type a2, Function::argument_3_type a3, Function::argument_4_type a4, Function::argument_5_type a5, Function::argument_6_type a6) :
|
|
std_arity1opmf_const<Function>(oi, reinterpret_cast<pmf1type>(f.pmf0)), std_arity6_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type>(f), arg2val(a2), arg3val(a3), arg4val(a4), arg5val(a5), arg6val(a6) {}
|
|
inline std_bndr_const_obj_2_3_4_5_6(const std_bndr_const_obj_2_3_4_5_6& bndri) :
|
|
std_arity1opmf_const<Function>(bndri.objval, reinterpret_cast<pmf1type>(bndri.pmf0)), std_arity6_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type>(bndri), arg2val(bndri.arg2val), arg3val(bndri.arg3val), arg4val(bndri.arg4val), arg5val(bndri.arg5val), arg6val(bndri.arg6val) {}
|
|
inline Function::result_type operator()(Function::first_argument_type a1) const {
|
|
pmf6type pmf = reinterpret_cast<pmf6type>(pmf0);
|
|
return (objval.*pmf)(a1, arg2val, arg3val, arg4val, arg5val, arg6val);
|
|
}
|
|
public:
|
|
Function::second_argument_type arg2val;
|
|
Function::argument_3_type arg3val;
|
|
Function::argument_4_type arg4val;
|
|
Function::argument_5_type arg5val;
|
|
Function::argument_6_type arg6val;
|
|
};
|
|
|
|
template<class Function> class std_bndr_const_obj_1_3_4_5_6 :
|
|
public std_arity1opmf_const<Function>,
|
|
private std_arity6_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type> {
|
|
public:
|
|
explicit inline std_bndr_const_obj_1_3_4_5_6(const Function::object_type& oi, const Function &f, Function::first_argument_type a1, Function::argument_3_type a3, Function::argument_4_type a4, Function::argument_5_type a5, Function::argument_6_type a6) :
|
|
std_arity1opmf_const<Function>(oi, reinterpret_cast<pmf1type>(f.pmf0)), std_arity6_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type>(f), arg1val(a1), arg3val(a3), arg4val(a4), arg5val(a5), arg6val(a6) {}
|
|
inline std_bndr_const_obj_1_3_4_5_6(const std_bndr_const_obj_1_3_4_5_6& bndri) :
|
|
std_arity1opmf_const<Function>(bndri.objval, reinterpret_cast<pmf1type>(bndri.pmf0)), std_arity6_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type>(bndri), arg1val(bndri.arg1val), arg3val(bndri.arg3val), arg4val(bndri.arg4val), arg5val(bndri.arg5val), arg6val(bndri.arg6val) {}
|
|
inline Function::result_type operator()(Function::second_argument_type a2) const {
|
|
pmf6type pmf = reinterpret_cast<pmf6type>(pmf0);
|
|
return (objval.*pmf)(arg1val, a2, arg3val, arg4val, arg5val, arg6val);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::argument_3_type arg3val;
|
|
Function::argument_4_type arg4val;
|
|
Function::argument_5_type arg5val;
|
|
Function::argument_6_type arg6val;
|
|
};
|
|
|
|
template<class Function> class std_bndr_const_obj_1_2_4_5_6 :
|
|
public std_arity1opmf_const<Function>,
|
|
private std_arity6_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type> {
|
|
public:
|
|
explicit inline std_bndr_const_obj_1_2_4_5_6(const Function::object_type& oi, const Function &f, Function::first_argument_type a1, Function::second_argument_type a2, Function::argument_4_type a4, Function::argument_5_type a5, Function::argument_6_type a6) :
|
|
std_arity1opmf_const<Function>(oi, reinterpret_cast<pmf1type>(f.pmf0)), std_arity6_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type>(f), arg1val(a1), arg2val(a2), arg4val(a4), arg5val(a5), arg6val(a6) {}
|
|
inline std_bndr_const_obj_1_2_4_5_6(const std_bndr_const_obj_1_2_4_5_6& bndri) :
|
|
std_arity1opmf_const<Function>(bndri.objval, reinterpret_cast<pmf1type>(bndri.pmf0)), std_arity6_const_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type, Function::result_type>(bndri), arg1val(bndri.arg1val), arg2val(bndri.arg2val), arg4val(bndri.arg4val), arg5val(bndri.arg5val), arg6val(bndri.arg6val) {}
|
|
inline Function::result_type operator()(Function::argument_3_type a3) const {
|
|
pmf6type pmf = reinterpret_cast<pmf6type>(pmf0);
|
|
return (objval.*pmf)(arg1val, arg2val, a3, arg4val, arg5val, arg6val);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::second_argument_type arg2val;
|
|
Function::argument_4_type arg4val;
|
|
Function::argument_5_type arg5val;
|
|
Function::argument_6_type arg6val;
|
|
};
|
|
|
|
|
|
|
|
// Template Functions for binding arity 6 to arity 1
|
|
|
|
|
|
// Template Functions for binding pmf of arity 6 to arity 1
|
|
|
|
template<class Function, class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6> inline std_bndr_mf_2_3_4_5_6<Function>
|
|
std_bind_mf_2_3_4_5_6(const Function &f, A2 a2,
|
|
A3 a3,
|
|
A4 a4,
|
|
A5 a5,
|
|
A6 a6) {
|
|
return std_bndr_mf_2_3_4_5_6<Function>(f, Function::second_argument_type(a2), Function::argument_3_type(a3), Function::argument_4_type(a4), Function::argument_5_type(a5), Function::argument_6_type(a6));
|
|
};
|
|
|
|
template<class Function, class A1,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6> inline std_bndr_mf_1_3_4_5_6<Function>
|
|
std_bind_mf_1_3_4_5_6(const Function &f, A1 a1,
|
|
A3 a3,
|
|
A4 a4,
|
|
A5 a5,
|
|
A6 a6) {
|
|
return std_bndr_mf_1_3_4_5_6<Function>(f, Function::first_argument_type(a1), Function::argument_3_type(a3), Function::argument_4_type(a4), Function::argument_5_type(a5), Function::argument_6_type(a6));
|
|
};
|
|
|
|
template<class Function, class A1,
|
|
class A2,
|
|
class A4,
|
|
class A5,
|
|
class A6> inline std_bndr_mf_1_2_4_5_6<Function>
|
|
std_bind_mf_1_2_4_5_6(const Function &f, A1 a1,
|
|
A2 a2,
|
|
A4 a4,
|
|
A5 a5,
|
|
A6 a6) {
|
|
return std_bndr_mf_1_2_4_5_6<Function>(f, Function::first_argument_type(a1), Function::second_argument_type(a2), Function::argument_4_type(a4), Function::argument_5_type(a5), Function::argument_6_type(a6));
|
|
};
|
|
|
|
|
|
|
|
// Template Functions for binding const pmf of arity 6 to arity 1
|
|
|
|
template<class Function, class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6> inline std_bndr_const_mf_2_3_4_5_6<Function>
|
|
std_bind_const_mf_2_3_4_5_6(const Function &f, A2 a2,
|
|
A3 a3,
|
|
A4 a4,
|
|
A5 a5,
|
|
A6 a6) {
|
|
return std_bndr_const_mf_2_3_4_5_6<Function>(f, Function::second_argument_type(a2), Function::argument_3_type(a3), Function::argument_4_type(a4), Function::argument_5_type(a5), Function::argument_6_type(a6));
|
|
};
|
|
|
|
template<class Function, class A1,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6> inline std_bndr_const_mf_1_3_4_5_6<Function>
|
|
std_bind_const_mf_1_3_4_5_6(const Function &f, A1 a1,
|
|
A3 a3,
|
|
A4 a4,
|
|
A5 a5,
|
|
A6 a6) {
|
|
return std_bndr_const_mf_1_3_4_5_6<Function>(f, Function::first_argument_type(a1), Function::argument_3_type(a3), Function::argument_4_type(a4), Function::argument_5_type(a5), Function::argument_6_type(a6));
|
|
};
|
|
|
|
template<class Function, class A1,
|
|
class A2,
|
|
class A4,
|
|
class A5,
|
|
class A6> inline std_bndr_const_mf_1_2_4_5_6<Function>
|
|
std_bind_const_mf_1_2_4_5_6(const Function &f, A1 a1,
|
|
A2 a2,
|
|
A4 a4,
|
|
A5 a5,
|
|
A6 a6) {
|
|
return std_bndr_const_mf_1_2_4_5_6<Function>(f, Function::first_argument_type(a1), Function::second_argument_type(a2), Function::argument_4_type(a4), Function::argument_5_type(a5), Function::argument_6_type(a6));
|
|
};
|
|
|
|
|
|
|
|
// Template Functions for binding obj&pmf Ref of arity 6 to arity 1
|
|
|
|
template<class Function, class Object,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6> inline std_bndr_obj_2_3_4_5_6<Function>
|
|
std_bind_obj_2_3_4_5_6(Object& oi, const Function &f, A2 a2,
|
|
A3 a3,
|
|
A4 a4,
|
|
A5 a5,
|
|
A6 a6) {
|
|
return std_bndr_obj_2_3_4_5_6<Function>(static_cast<Function::object_type&>(oi), f, Function::second_argument_type(a2), Function::argument_3_type(a3), Function::argument_4_type(a4), Function::argument_5_type(a5), Function::argument_6_type(a6));
|
|
};
|
|
|
|
template<class Function, class Object,
|
|
class A1,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6> inline std_bndr_obj_1_3_4_5_6<Function>
|
|
std_bind_obj_1_3_4_5_6(Object& oi, const Function &f, A1 a1,
|
|
A3 a3,
|
|
A4 a4,
|
|
A5 a5,
|
|
A6 a6) {
|
|
return std_bndr_obj_1_3_4_5_6<Function>(static_cast<Function::object_type&>(oi), f, Function::first_argument_type(a1), Function::argument_3_type(a3), Function::argument_4_type(a4), Function::argument_5_type(a5), Function::argument_6_type(a6));
|
|
};
|
|
|
|
template<class Function, class Object,
|
|
class A1,
|
|
class A2,
|
|
class A4,
|
|
class A5,
|
|
class A6> inline std_bndr_obj_1_2_4_5_6<Function>
|
|
std_bind_obj_1_2_4_5_6(Object& oi, const Function &f, A1 a1,
|
|
A2 a2,
|
|
A4 a4,
|
|
A5 a5,
|
|
A6 a6) {
|
|
return std_bndr_obj_1_2_4_5_6<Function>(static_cast<Function::object_type&>(oi), f, Function::first_argument_type(a1), Function::second_argument_type(a2), Function::argument_4_type(a4), Function::argument_5_type(a5), Function::argument_6_type(a6));
|
|
};
|
|
|
|
|
|
|
|
// Template Functions for binding const obj&pmf Ref of arity 6 to arity 1
|
|
|
|
template<class Function, const class Object,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6> inline std_bndr_const_obj_2_3_4_5_6<Function>
|
|
std_bind_const_obj_2_3_4_5_6(const Object& oi, const Function &f, A2 a2,
|
|
A3 a3,
|
|
A4 a4,
|
|
A5 a5,
|
|
A6 a6) {
|
|
return std_bndr_const_obj_2_3_4_5_6<Function>(static_cast<Function::object_type&>(oi), f, Function::second_argument_type(a2), Function::argument_3_type(a3), Function::argument_4_type(a4), Function::argument_5_type(a5), Function::argument_6_type(a6));
|
|
};
|
|
|
|
template<class Function, const class Object,
|
|
class A1,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6> inline std_bndr_const_obj_1_3_4_5_6<Function>
|
|
std_bind_const_obj_1_3_4_5_6(const Object& oi, const Function &f, A1 a1,
|
|
A3 a3,
|
|
A4 a4,
|
|
A5 a5,
|
|
A6 a6) {
|
|
return std_bndr_const_obj_1_3_4_5_6<Function>(static_cast<Function::object_type&>(oi), f, Function::first_argument_type(a1), Function::argument_3_type(a3), Function::argument_4_type(a4), Function::argument_5_type(a5), Function::argument_6_type(a6));
|
|
};
|
|
|
|
template<class Function, const class Object,
|
|
class A1,
|
|
class A2,
|
|
class A4,
|
|
class A5,
|
|
class A6> inline std_bndr_const_obj_1_2_4_5_6<Function>
|
|
std_bind_const_obj_1_2_4_5_6(const Object& oi, const Function &f, A1 a1,
|
|
A2 a2,
|
|
A4 a4,
|
|
A5 a5,
|
|
A6 a6) {
|
|
return std_bndr_const_obj_1_2_4_5_6<Function>(static_cast<Function::object_type&>(oi), f, Function::first_argument_type(a1), Function::second_argument_type(a2), Function::argument_4_type(a4), Function::argument_5_type(a5), Function::argument_6_type(a6));
|
|
};
|
|
|
|
|
|
|
|
// Template Classes for binding arity 15 to 1
|
|
|
|
|
|
// Template Classes for binding pmf of arity 15 to arity 1
|
|
|
|
template<class Function> class std_bndr_mf_2_3_4_5_6_7_8_9_10_11_12_13_14_15 :
|
|
public std_arity1pmf<Function::object_type, Function::first_argument_type, Function::result_type>,
|
|
private std_arity15_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type,
|
|
Function::argument_7_type,
|
|
Function::argument_8_type,
|
|
Function::argument_9_type,
|
|
Function::argument_10_type,
|
|
Function::argument_11_type,
|
|
Function::argument_12_type,
|
|
Function::argument_13_type,
|
|
Function::argument_14_type,
|
|
Function::argument_15_type, Function::result_type> {
|
|
public:
|
|
explicit inline std_bndr_mf_2_3_4_5_6_7_8_9_10_11_12_13_14_15(const Function &f, Function::second_argument_type a2, Function::argument_3_type a3, Function::argument_4_type a4, Function::argument_5_type a5, Function::argument_6_type a6, Function::argument_7_type a7, Function::argument_8_type a8, Function::argument_9_type a9, Function::argument_10_type a10, Function::argument_11_type a11, Function::argument_12_type a12, Function::argument_13_type a13, Function::argument_14_type a14, Function::argument_15_type a15) :
|
|
std_arity1pmf<Function::object_type, Function::first_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(f.pmf0)), std_arity15_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type,
|
|
Function::argument_7_type,
|
|
Function::argument_8_type,
|
|
Function::argument_9_type,
|
|
Function::argument_10_type,
|
|
Function::argument_11_type,
|
|
Function::argument_12_type,
|
|
Function::argument_13_type,
|
|
Function::argument_14_type,
|
|
Function::argument_15_type, Function::result_type>(f), arg2val(a2), arg3val(a3), arg4val(a4), arg5val(a5), arg6val(a6), arg7val(a7), arg8val(a8), arg9val(a9), arg10val(a10), arg11val(a11), arg12val(a12), arg13val(a13), arg14val(a14), arg15val(a15) {}
|
|
inline std_bndr_mf_2_3_4_5_6_7_8_9_10_11_12_13_14_15(const std_bndr_mf_2_3_4_5_6_7_8_9_10_11_12_13_14_15& bndri) :
|
|
std_arity1pmf<Function::object_type, Function::first_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(bndri.pmf0)), std_arity15_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type,
|
|
Function::argument_7_type,
|
|
Function::argument_8_type,
|
|
Function::argument_9_type,
|
|
Function::argument_10_type,
|
|
Function::argument_11_type,
|
|
Function::argument_12_type,
|
|
Function::argument_13_type,
|
|
Function::argument_14_type,
|
|
Function::argument_15_type, Function::result_type>(bndri), arg2val(bndri.arg2val), arg3val(bndri.arg3val), arg4val(bndri.arg4val), arg5val(bndri.arg5val), arg6val(bndri.arg6val), arg7val(bndri.arg7val), arg8val(bndri.arg8val), arg9val(bndri.arg9val), arg10val(bndri.arg10val), arg11val(bndri.arg11val), arg12val(bndri.arg12val), arg13val(bndri.arg13val), arg14val(bndri.arg14val), arg15val(bndri.arg15val) {}
|
|
inline virtual Function::result_type operator()(Function::object_type& o, Function::first_argument_type a1) const {
|
|
pmf15type pmf = reinterpret_cast<pmf15type>(pmf0);
|
|
return (o.*pmf)(a1, arg2val, arg3val, arg4val, arg5val, arg6val, arg7val, arg8val, arg9val, arg10val, arg11val, arg12val, arg13val, arg14val, arg15val);
|
|
}
|
|
public:
|
|
Function::second_argument_type arg2val;
|
|
Function::argument_3_type arg3val;
|
|
Function::argument_4_type arg4val;
|
|
Function::argument_5_type arg5val;
|
|
Function::argument_6_type arg6val;
|
|
Function::argument_7_type arg7val;
|
|
Function::argument_8_type arg8val;
|
|
Function::argument_9_type arg9val;
|
|
Function::argument_10_type arg10val;
|
|
Function::argument_11_type arg11val;
|
|
Function::argument_12_type arg12val;
|
|
Function::argument_13_type arg13val;
|
|
Function::argument_14_type arg14val;
|
|
Function::argument_15_type arg15val;
|
|
};
|
|
|
|
template<class Function> class std_bndr_mf_1_3_4_5_6_7_8_9_10_11_12_13_14_15 :
|
|
public std_arity1pmf<Function::object_type, Function::second_argument_type, Function::result_type>,
|
|
private std_arity15_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type,
|
|
Function::argument_7_type,
|
|
Function::argument_8_type,
|
|
Function::argument_9_type,
|
|
Function::argument_10_type,
|
|
Function::argument_11_type,
|
|
Function::argument_12_type,
|
|
Function::argument_13_type,
|
|
Function::argument_14_type,
|
|
Function::argument_15_type, Function::result_type> {
|
|
public:
|
|
explicit inline std_bndr_mf_1_3_4_5_6_7_8_9_10_11_12_13_14_15(const Function &f, Function::first_argument_type a1, Function::argument_3_type a3, Function::argument_4_type a4, Function::argument_5_type a5, Function::argument_6_type a6, Function::argument_7_type a7, Function::argument_8_type a8, Function::argument_9_type a9, Function::argument_10_type a10, Function::argument_11_type a11, Function::argument_12_type a12, Function::argument_13_type a13, Function::argument_14_type a14, Function::argument_15_type a15) :
|
|
std_arity1pmf<Function::object_type, Function::second_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(f.pmf0)), std_arity15_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type,
|
|
Function::argument_7_type,
|
|
Function::argument_8_type,
|
|
Function::argument_9_type,
|
|
Function::argument_10_type,
|
|
Function::argument_11_type,
|
|
Function::argument_12_type,
|
|
Function::argument_13_type,
|
|
Function::argument_14_type,
|
|
Function::argument_15_type, Function::result_type>(f), arg1val(a1), arg3val(a3), arg4val(a4), arg5val(a5), arg6val(a6), arg7val(a7), arg8val(a8), arg9val(a9), arg10val(a10), arg11val(a11), arg12val(a12), arg13val(a13), arg14val(a14), arg15val(a15) {}
|
|
inline std_bndr_mf_1_3_4_5_6_7_8_9_10_11_12_13_14_15(const std_bndr_mf_1_3_4_5_6_7_8_9_10_11_12_13_14_15& bndri) :
|
|
std_arity1pmf<Function::object_type, Function::second_argument_type, Function::result_type>(reinterpret_cast<pmf1type>(bndri.pmf0)), std_arity15_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type,
|
|
Function::argument_7_type,
|
|
Function::argument_8_type,
|
|
Function::argument_9_type,
|
|
Function::argument_10_type,
|
|
Function::argument_11_type,
|
|
Function::argument_12_type,
|
|
Function::argument_13_type,
|
|
Function::argument_14_type,
|
|
Function::argument_15_type, Function::result_type>(bndri), arg1val(bndri.arg1val), arg3val(bndri.arg3val), arg4val(bndri.arg4val), arg5val(bndri.arg5val), arg6val(bndri.arg6val), arg7val(bndri.arg7val), arg8val(bndri.arg8val), arg9val(bndri.arg9val), arg10val(bndri.arg10val), arg11val(bndri.arg11val), arg12val(bndri.arg12val), arg13val(bndri.arg13val), arg14val(bndri.arg14val), arg15val(bndri.arg15val) {}
|
|
inline virtual Function::result_type operator()(Function::object_type& o, Function::second_argument_type a2) const {
|
|
pmf15type pmf = reinterpret_cast<pmf15type>(pmf0);
|
|
return (o.*pmf)(arg1val, a2, arg3val, arg4val, arg5val, arg6val, arg7val, arg8val, arg9val, arg10val, arg11val, arg12val, arg13val, arg14val, arg15val);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::argument_3_type arg3val;
|
|
Function::argument_4_type arg4val;
|
|
Function::argument_5_type arg5val;
|
|
Function::argument_6_type arg6val;
|
|
Function::argument_7_type arg7val;
|
|
Function::argument_8_type arg8val;
|
|
Function::argument_9_type arg9val;
|
|
Function::argument_10_type arg10val;
|
|
Function::argument_11_type arg11val;
|
|
Function::argument_12_type arg12val;
|
|
Function::argument_13_type arg13val;
|
|
Function::argument_14_type arg14val;
|
|
Function::argument_15_type arg15val;
|
|
};
|
|
|
|
template<class Function> class std_bndr_mf_1_2_4_5_6_7_8_9_10_11_12_13_14_15 :
|
|
public std_arity1pmf<Function::object_type, Function::argument_3_type, Function::result_type>,
|
|
private std_arity15_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type,
|
|
Function::argument_7_type,
|
|
Function::argument_8_type,
|
|
Function::argument_9_type,
|
|
Function::argument_10_type,
|
|
Function::argument_11_type,
|
|
Function::argument_12_type,
|
|
Function::argument_13_type,
|
|
Function::argument_14_type,
|
|
Function::argument_15_type, Function::result_type> {
|
|
public:
|
|
explicit inline std_bndr_mf_1_2_4_5_6_7_8_9_10_11_12_13_14_15(const Function &f, Function::first_argument_type a1, Function::second_argument_type a2, Function::argument_4_type a4, Function::argument_5_type a5, Function::argument_6_type a6, Function::argument_7_type a7, Function::argument_8_type a8, Function::argument_9_type a9, Function::argument_10_type a10, Function::argument_11_type a11, Function::argument_12_type a12, Function::argument_13_type a13, Function::argument_14_type a14, Function::argument_15_type a15) :
|
|
std_arity1pmf<Function::object_type, Function::argument_3_type, Function::result_type>(reinterpret_cast<pmf1type>(f.pmf0)), std_arity15_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type,
|
|
Function::argument_7_type,
|
|
Function::argument_8_type,
|
|
Function::argument_9_type,
|
|
Function::argument_10_type,
|
|
Function::argument_11_type,
|
|
Function::argument_12_type,
|
|
Function::argument_13_type,
|
|
Function::argument_14_type,
|
|
Function::argument_15_type, Function::result_type>(f), arg1val(a1), arg2val(a2), arg4val(a4), arg5val(a5), arg6val(a6), arg7val(a7), arg8val(a8), arg9val(a9), arg10val(a10), arg11val(a11), arg12val(a12), arg13val(a13), arg14val(a14), arg15val(a15) {}
|
|
inline std_bndr_mf_1_2_4_5_6_7_8_9_10_11_12_13_14_15(const std_bndr_mf_1_2_4_5_6_7_8_9_10_11_12_13_14_15& bndri) :
|
|
std_arity1pmf<Function::object_type, Function::argument_3_type, Function::result_type>(reinterpret_cast<pmf1type>(bndri.pmf0)), std_arity15_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type,
|
|
Function::argument_7_type,
|
|
Function::argument_8_type,
|
|
Function::argument_9_type,
|
|
Function::argument_10_type,
|
|
Function::argument_11_type,
|
|
Function::argument_12_type,
|
|
Function::argument_13_type,
|
|
Function::argument_14_type,
|
|
Function::argument_15_type, Function::result_type>(bndri), arg1val(bndri.arg1val), arg2val(bndri.arg2val), arg4val(bndri.arg4val), arg5val(bndri.arg5val), arg6val(bndri.arg6val), arg7val(bndri.arg7val), arg8val(bndri.arg8val), arg9val(bndri.arg9val), arg10val(bndri.arg10val), arg11val(bndri.arg11val), arg12val(bndri.arg12val), arg13val(bndri.arg13val), arg14val(bndri.arg14val), arg15val(bndri.arg15val) {}
|
|
inline virtual Function::result_type operator()(Function::object_type& o, Function::argument_3_type a3) const {
|
|
pmf15type pmf = reinterpret_cast<pmf15type>(pmf0);
|
|
return (o.*pmf)(arg1val, arg2val, a3, arg4val, arg5val, arg6val, arg7val, arg8val, arg9val, arg10val, arg11val, arg12val, arg13val, arg14val, arg15val);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::second_argument_type arg2val;
|
|
Function::argument_4_type arg4val;
|
|
Function::argument_5_type arg5val;
|
|
Function::argument_6_type arg6val;
|
|
Function::argument_7_type arg7val;
|
|
Function::argument_8_type arg8val;
|
|
Function::argument_9_type arg9val;
|
|
Function::argument_10_type arg10val;
|
|
Function::argument_11_type arg11val;
|
|
Function::argument_12_type arg12val;
|
|
Function::argument_13_type arg13val;
|
|
Function::argument_14_type arg14val;
|
|
Function::argument_15_type arg15val;
|
|
};
|
|
|
|
|
|
|
|
// Template Classes for binding obj&pmf Ref of arity 15 to arity 1
|
|
|
|
template<class Function> class std_bndr_obj_2_3_4_5_6_7_8_9_10_11_12_13_14_15 :
|
|
public std_arity1opmf<Function>,
|
|
private std_arity15_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type,
|
|
Function::argument_7_type,
|
|
Function::argument_8_type,
|
|
Function::argument_9_type,
|
|
Function::argument_10_type,
|
|
Function::argument_11_type,
|
|
Function::argument_12_type,
|
|
Function::argument_13_type,
|
|
Function::argument_14_type,
|
|
Function::argument_15_type, Function::result_type> {
|
|
public:
|
|
explicit inline std_bndr_obj_2_3_4_5_6_7_8_9_10_11_12_13_14_15(Function::object_type& oi, const Function &f, Function::second_argument_type a2, Function::argument_3_type a3, Function::argument_4_type a4, Function::argument_5_type a5, Function::argument_6_type a6, Function::argument_7_type a7, Function::argument_8_type a8, Function::argument_9_type a9, Function::argument_10_type a10, Function::argument_11_type a11, Function::argument_12_type a12, Function::argument_13_type a13, Function::argument_14_type a14, Function::argument_15_type a15) :
|
|
std_arity1opmf<Function>(oi, reinterpret_cast<pmf1type>(f.pmf0)), std_arity15_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type,
|
|
Function::argument_7_type,
|
|
Function::argument_8_type,
|
|
Function::argument_9_type,
|
|
Function::argument_10_type,
|
|
Function::argument_11_type,
|
|
Function::argument_12_type,
|
|
Function::argument_13_type,
|
|
Function::argument_14_type,
|
|
Function::argument_15_type, Function::result_type>(f), arg2val(a2), arg3val(a3), arg4val(a4), arg5val(a5), arg6val(a6), arg7val(a7), arg8val(a8), arg9val(a9), arg10val(a10), arg11val(a11), arg12val(a12), arg13val(a13), arg14val(a14), arg15val(a15) {}
|
|
inline std_bndr_obj_2_3_4_5_6_7_8_9_10_11_12_13_14_15(const std_bndr_obj_2_3_4_5_6_7_8_9_10_11_12_13_14_15& bndri) :
|
|
std_arity1opmf<Function>(bndri.objval, reinterpret_cast<pmf1type>(bndri.pmf0)), std_arity15_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type,
|
|
Function::argument_7_type,
|
|
Function::argument_8_type,
|
|
Function::argument_9_type,
|
|
Function::argument_10_type,
|
|
Function::argument_11_type,
|
|
Function::argument_12_type,
|
|
Function::argument_13_type,
|
|
Function::argument_14_type,
|
|
Function::argument_15_type, Function::result_type>(bndri), arg2val(bndri.arg2val), arg3val(bndri.arg3val), arg4val(bndri.arg4val), arg5val(bndri.arg5val), arg6val(bndri.arg6val), arg7val(bndri.arg7val), arg8val(bndri.arg8val), arg9val(bndri.arg9val), arg10val(bndri.arg10val), arg11val(bndri.arg11val), arg12val(bndri.arg12val), arg13val(bndri.arg13val), arg14val(bndri.arg14val), arg15val(bndri.arg15val) {}
|
|
inline Function::result_type operator()(Function::first_argument_type a1) const {
|
|
pmf15type pmf = reinterpret_cast<pmf15type>(pmf0);
|
|
return (objval.*pmf)(a1, arg2val, arg3val, arg4val, arg5val, arg6val, arg7val, arg8val, arg9val, arg10val, arg11val, arg12val, arg13val, arg14val, arg15val);
|
|
}
|
|
public:
|
|
Function::second_argument_type arg2val;
|
|
Function::argument_3_type arg3val;
|
|
Function::argument_4_type arg4val;
|
|
Function::argument_5_type arg5val;
|
|
Function::argument_6_type arg6val;
|
|
Function::argument_7_type arg7val;
|
|
Function::argument_8_type arg8val;
|
|
Function::argument_9_type arg9val;
|
|
Function::argument_10_type arg10val;
|
|
Function::argument_11_type arg11val;
|
|
Function::argument_12_type arg12val;
|
|
Function::argument_13_type arg13val;
|
|
Function::argument_14_type arg14val;
|
|
Function::argument_15_type arg15val;
|
|
};
|
|
|
|
template<class Function> class std_bndr_obj_1_3_4_5_6_7_8_9_10_11_12_13_14_15 :
|
|
public std_arity1opmf<Function>,
|
|
private std_arity15_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type,
|
|
Function::argument_7_type,
|
|
Function::argument_8_type,
|
|
Function::argument_9_type,
|
|
Function::argument_10_type,
|
|
Function::argument_11_type,
|
|
Function::argument_12_type,
|
|
Function::argument_13_type,
|
|
Function::argument_14_type,
|
|
Function::argument_15_type, Function::result_type> {
|
|
public:
|
|
explicit inline std_bndr_obj_1_3_4_5_6_7_8_9_10_11_12_13_14_15(Function::object_type& oi, const Function &f, Function::first_argument_type a1, Function::argument_3_type a3, Function::argument_4_type a4, Function::argument_5_type a5, Function::argument_6_type a6, Function::argument_7_type a7, Function::argument_8_type a8, Function::argument_9_type a9, Function::argument_10_type a10, Function::argument_11_type a11, Function::argument_12_type a12, Function::argument_13_type a13, Function::argument_14_type a14, Function::argument_15_type a15) :
|
|
std_arity1opmf<Function>(oi, reinterpret_cast<pmf1type>(f.pmf0)), std_arity15_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type,
|
|
Function::argument_7_type,
|
|
Function::argument_8_type,
|
|
Function::argument_9_type,
|
|
Function::argument_10_type,
|
|
Function::argument_11_type,
|
|
Function::argument_12_type,
|
|
Function::argument_13_type,
|
|
Function::argument_14_type,
|
|
Function::argument_15_type, Function::result_type>(f), arg1val(a1), arg3val(a3), arg4val(a4), arg5val(a5), arg6val(a6), arg7val(a7), arg8val(a8), arg9val(a9), arg10val(a10), arg11val(a11), arg12val(a12), arg13val(a13), arg14val(a14), arg15val(a15) {}
|
|
inline std_bndr_obj_1_3_4_5_6_7_8_9_10_11_12_13_14_15(const std_bndr_obj_1_3_4_5_6_7_8_9_10_11_12_13_14_15& bndri) :
|
|
std_arity1opmf<Function>(bndri.objval, reinterpret_cast<pmf1type>(bndri.pmf0)), std_arity15_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type,
|
|
Function::argument_7_type,
|
|
Function::argument_8_type,
|
|
Function::argument_9_type,
|
|
Function::argument_10_type,
|
|
Function::argument_11_type,
|
|
Function::argument_12_type,
|
|
Function::argument_13_type,
|
|
Function::argument_14_type,
|
|
Function::argument_15_type, Function::result_type>(bndri), arg1val(bndri.arg1val), arg3val(bndri.arg3val), arg4val(bndri.arg4val), arg5val(bndri.arg5val), arg6val(bndri.arg6val), arg7val(bndri.arg7val), arg8val(bndri.arg8val), arg9val(bndri.arg9val), arg10val(bndri.arg10val), arg11val(bndri.arg11val), arg12val(bndri.arg12val), arg13val(bndri.arg13val), arg14val(bndri.arg14val), arg15val(bndri.arg15val) {}
|
|
inline Function::result_type operator()(Function::second_argument_type a2) const {
|
|
pmf15type pmf = reinterpret_cast<pmf15type>(pmf0);
|
|
return (objval.*pmf)(arg1val, a2, arg3val, arg4val, arg5val, arg6val, arg7val, arg8val, arg9val, arg10val, arg11val, arg12val, arg13val, arg14val, arg15val);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::argument_3_type arg3val;
|
|
Function::argument_4_type arg4val;
|
|
Function::argument_5_type arg5val;
|
|
Function::argument_6_type arg6val;
|
|
Function::argument_7_type arg7val;
|
|
Function::argument_8_type arg8val;
|
|
Function::argument_9_type arg9val;
|
|
Function::argument_10_type arg10val;
|
|
Function::argument_11_type arg11val;
|
|
Function::argument_12_type arg12val;
|
|
Function::argument_13_type arg13val;
|
|
Function::argument_14_type arg14val;
|
|
Function::argument_15_type arg15val;
|
|
};
|
|
|
|
template<class Function> class std_bndr_obj_1_2_4_5_6_7_8_9_10_11_12_13_14_15 :
|
|
public std_arity1opmf<Function>,
|
|
private std_arity15_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type,
|
|
Function::argument_7_type,
|
|
Function::argument_8_type,
|
|
Function::argument_9_type,
|
|
Function::argument_10_type,
|
|
Function::argument_11_type,
|
|
Function::argument_12_type,
|
|
Function::argument_13_type,
|
|
Function::argument_14_type,
|
|
Function::argument_15_type, Function::result_type> {
|
|
public:
|
|
explicit inline std_bndr_obj_1_2_4_5_6_7_8_9_10_11_12_13_14_15(Function::object_type& oi, const Function &f, Function::first_argument_type a1, Function::second_argument_type a2, Function::argument_4_type a4, Function::argument_5_type a5, Function::argument_6_type a6, Function::argument_7_type a7, Function::argument_8_type a8, Function::argument_9_type a9, Function::argument_10_type a10, Function::argument_11_type a11, Function::argument_12_type a12, Function::argument_13_type a13, Function::argument_14_type a14, Function::argument_15_type a15) :
|
|
std_arity1opmf<Function>(oi, reinterpret_cast<pmf1type>(f.pmf0)), std_arity15_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type,
|
|
Function::argument_7_type,
|
|
Function::argument_8_type,
|
|
Function::argument_9_type,
|
|
Function::argument_10_type,
|
|
Function::argument_11_type,
|
|
Function::argument_12_type,
|
|
Function::argument_13_type,
|
|
Function::argument_14_type,
|
|
Function::argument_15_type, Function::result_type>(f), arg1val(a1), arg2val(a2), arg4val(a4), arg5val(a5), arg6val(a6), arg7val(a7), arg8val(a8), arg9val(a9), arg10val(a10), arg11val(a11), arg12val(a12), arg13val(a13), arg14val(a14), arg15val(a15) {}
|
|
inline std_bndr_obj_1_2_4_5_6_7_8_9_10_11_12_13_14_15(const std_bndr_obj_1_2_4_5_6_7_8_9_10_11_12_13_14_15& bndri) :
|
|
std_arity1opmf<Function>(bndri.objval, reinterpret_cast<pmf1type>(bndri.pmf0)), std_arity15_mf<Function::object_type, Function::first_argument_type,
|
|
Function::second_argument_type,
|
|
Function::argument_3_type,
|
|
Function::argument_4_type,
|
|
Function::argument_5_type,
|
|
Function::argument_6_type,
|
|
Function::argument_7_type,
|
|
Function::argument_8_type,
|
|
Function::argument_9_type,
|
|
Function::argument_10_type,
|
|
Function::argument_11_type,
|
|
Function::argument_12_type,
|
|
Function::argument_13_type,
|
|
Function::argument_14_type,
|
|
Function::argument_15_type, Function::result_type>(bndri), arg1val(bndri.arg1val), arg2val(bndri.arg2val), arg4val(bndri.arg4val), arg5val(bndri.arg5val), arg6val(bndri.arg6val), arg7val(bndri.arg7val), arg8val(bndri.arg8val), arg9val(bndri.arg9val), arg10val(bndri.arg10val), arg11val(bndri.arg11val), arg12val(bndri.arg12val), arg13val(bndri.arg13val), arg14val(bndri.arg14val), arg15val(bndri.arg15val) {}
|
|
inline Function::result_type operator()(Function::argument_3_type a3) const {
|
|
pmf15type pmf = reinterpret_cast<pmf15type>(pmf0);
|
|
return (objval.*pmf)(arg1val, arg2val, a3, arg4val, arg5val, arg6val, arg7val, arg8val, arg9val, arg10val, arg11val, arg12val, arg13val, arg14val, arg15val);
|
|
}
|
|
public:
|
|
Function::first_argument_type arg1val;
|
|
Function::second_argument_type arg2val;
|
|
Function::argument_4_type arg4val;
|
|
Function::argument_5_type arg5val;
|
|
Function::argument_6_type arg6val;
|
|
Function::argument_7_type arg7val;
|
|
Function::argument_8_type arg8val;
|
|
Function::argument_9_type arg9val;
|
|
Function::argument_10_type arg10val;
|
|
Function::argument_11_type arg11val;
|
|
Function::argument_12_type arg12val;
|
|
Function::argument_13_type arg13val;
|
|
Function::argument_14_type arg14val;
|
|
Function::argument_15_type arg15val;
|
|
};
|
|
|
|
|
|
|
|
// Template Functions for binding arity 15 to 1
|
|
|
|
|
|
// Template Functions for binding pmf of arity 15 to arity 1
|
|
|
|
template<class Function, class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6,
|
|
class A7,
|
|
class A8,
|
|
class A9,
|
|
class A10,
|
|
class A11,
|
|
class A12,
|
|
class A13,
|
|
class A14,
|
|
class A15> inline std_bndr_mf_2_3_4_5_6_7_8_9_10_11_12_13_14_15<Function>
|
|
std_bind_mf_2_3_4_5_6_7_8_9_10_11_12_13_14_15(const Function &f, A2 a2,
|
|
A3 a3,
|
|
A4 a4,
|
|
A5 a5,
|
|
A6 a6,
|
|
A7 a7,
|
|
A8 a8,
|
|
A9 a9,
|
|
A10 a10,
|
|
A11 a11,
|
|
A12 a12,
|
|
A13 a13,
|
|
A14 a14,
|
|
A15 a15) {
|
|
return std_bndr_mf_2_3_4_5_6_7_8_9_10_11_12_13_14_15<Function>(f, Function::second_argument_type(a2), Function::argument_3_type(a3), Function::argument_4_type(a4), Function::argument_5_type(a5), Function::argument_6_type(a6), Function::argument_7_type(a7), Function::argument_8_type(a8), Function::argument_9_type(a9), Function::argument_10_type(a10), Function::argument_11_type(a11), Function::argument_12_type(a12), Function::argument_13_type(a13), Function::argument_14_type(a14), Function::argument_15_type(a15));
|
|
};
|
|
|
|
template<class Function, class A1,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6,
|
|
class A7,
|
|
class A8,
|
|
class A9,
|
|
class A10,
|
|
class A11,
|
|
class A12,
|
|
class A13,
|
|
class A14,
|
|
class A15> inline std_bndr_mf_1_3_4_5_6_7_8_9_10_11_12_13_14_15<Function>
|
|
std_bind_mf_1_3_4_5_6_7_8_9_10_11_12_13_14_15(const Function &f, A1 a1,
|
|
A3 a3,
|
|
A4 a4,
|
|
A5 a5,
|
|
A6 a6,
|
|
A7 a7,
|
|
A8 a8,
|
|
A9 a9,
|
|
A10 a10,
|
|
A11 a11,
|
|
A12 a12,
|
|
A13 a13,
|
|
A14 a14,
|
|
A15 a15) {
|
|
return std_bndr_mf_1_3_4_5_6_7_8_9_10_11_12_13_14_15<Function>(f, Function::first_argument_type(a1), Function::argument_3_type(a3), Function::argument_4_type(a4), Function::argument_5_type(a5), Function::argument_6_type(a6), Function::argument_7_type(a7), Function::argument_8_type(a8), Function::argument_9_type(a9), Function::argument_10_type(a10), Function::argument_11_type(a11), Function::argument_12_type(a12), Function::argument_13_type(a13), Function::argument_14_type(a14), Function::argument_15_type(a15));
|
|
};
|
|
|
|
template<class Function, class A1,
|
|
class A2,
|
|
class A4,
|
|
class A5,
|
|
class A6,
|
|
class A7,
|
|
class A8,
|
|
class A9,
|
|
class A10,
|
|
class A11,
|
|
class A12,
|
|
class A13,
|
|
class A14,
|
|
class A15> inline std_bndr_mf_1_2_4_5_6_7_8_9_10_11_12_13_14_15<Function>
|
|
std_bind_mf_1_2_4_5_6_7_8_9_10_11_12_13_14_15(const Function &f, A1 a1,
|
|
A2 a2,
|
|
A4 a4,
|
|
A5 a5,
|
|
A6 a6,
|
|
A7 a7,
|
|
A8 a8,
|
|
A9 a9,
|
|
A10 a10,
|
|
A11 a11,
|
|
A12 a12,
|
|
A13 a13,
|
|
A14 a14,
|
|
A15 a15) {
|
|
return std_bndr_mf_1_2_4_5_6_7_8_9_10_11_12_13_14_15<Function>(f, Function::first_argument_type(a1), Function::second_argument_type(a2), Function::argument_4_type(a4), Function::argument_5_type(a5), Function::argument_6_type(a6), Function::argument_7_type(a7), Function::argument_8_type(a8), Function::argument_9_type(a9), Function::argument_10_type(a10), Function::argument_11_type(a11), Function::argument_12_type(a12), Function::argument_13_type(a13), Function::argument_14_type(a14), Function::argument_15_type(a15));
|
|
};
|
|
|
|
|
|
|
|
// Template Functions for binding obj&pmf Ref of arity 15 to arity 1
|
|
|
|
template<class Function, class Object,
|
|
class A2,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6,
|
|
class A7,
|
|
class A8,
|
|
class A9,
|
|
class A10,
|
|
class A11,
|
|
class A12,
|
|
class A13,
|
|
class A14,
|
|
class A15> inline std_bndr_obj_2_3_4_5_6_7_8_9_10_11_12_13_14_15<Function>
|
|
std_bind_obj_2_3_4_5_6_7_8_9_10_11_12_13_14_15(Object& oi, const Function &f, A2 a2,
|
|
A3 a3,
|
|
A4 a4,
|
|
A5 a5,
|
|
A6 a6,
|
|
A7 a7,
|
|
A8 a8,
|
|
A9 a9,
|
|
A10 a10,
|
|
A11 a11,
|
|
A12 a12,
|
|
A13 a13,
|
|
A14 a14,
|
|
A15 a15) {
|
|
return std_bndr_obj_2_3_4_5_6_7_8_9_10_11_12_13_14_15<Function>(static_cast<Function::object_type&>(oi), f, Function::second_argument_type(a2), Function::argument_3_type(a3), Function::argument_4_type(a4), Function::argument_5_type(a5), Function::argument_6_type(a6), Function::argument_7_type(a7), Function::argument_8_type(a8), Function::argument_9_type(a9), Function::argument_10_type(a10), Function::argument_11_type(a11), Function::argument_12_type(a12), Function::argument_13_type(a13), Function::argument_14_type(a14), Function::argument_15_type(a15));
|
|
};
|
|
|
|
template<class Function, class Object,
|
|
class A1,
|
|
class A3,
|
|
class A4,
|
|
class A5,
|
|
class A6,
|
|
class A7,
|
|
class A8,
|
|
class A9,
|
|
class A10,
|
|
class A11,
|
|
class A12,
|
|
class A13,
|
|
class A14,
|
|
class A15> inline std_bndr_obj_1_3_4_5_6_7_8_9_10_11_12_13_14_15<Function>
|
|
std_bind_obj_1_3_4_5_6_7_8_9_10_11_12_13_14_15(Object& oi, const Function &f, A1 a1,
|
|
A3 a3,
|
|
A4 a4,
|
|
A5 a5,
|
|
A6 a6,
|
|
A7 a7,
|
|
A8 a8,
|
|
A9 a9,
|
|
A10 a10,
|
|
A11 a11,
|
|
A12 a12,
|
|
A13 a13,
|
|
A14 a14,
|
|
A15 a15) {
|
|
return std_bndr_obj_1_3_4_5_6_7_8_9_10_11_12_13_14_15<Function>(static_cast<Function::object_type&>(oi), f, Function::first_argument_type(a1), Function::argument_3_type(a3), Function::argument_4_type(a4), Function::argument_5_type(a5), Function::argument_6_type(a6), Function::argument_7_type(a7), Function::argument_8_type(a8), Function::argument_9_type(a9), Function::argument_10_type(a10), Function::argument_11_type(a11), Function::argument_12_type(a12), Function::argument_13_type(a13), Function::argument_14_type(a14), Function::argument_15_type(a15));
|
|
};
|
|
|
|
template<class Function, class Object,
|
|
class A1,
|
|
class A2,
|
|
class A4,
|
|
class A5,
|
|
class A6,
|
|
class A7,
|
|
class A8,
|
|
class A9,
|
|
class A10,
|
|
class A11,
|
|
class A12,
|
|
class A13,
|
|
class A14,
|
|
class A15> inline std_bndr_obj_1_2_4_5_6_7_8_9_10_11_12_13_14_15<Function>
|
|
std_bind_obj_1_2_4_5_6_7_8_9_10_11_12_13_14_15(Object& oi, const Function &f, A1 a1,
|
|
A2 a2,
|
|
A4 a4,
|
|
A5 a5,
|
|
A6 a6,
|
|
A7 a7,
|
|
A8 a8,
|
|
A9 a9,
|
|
A10 a10,
|
|
A11 a11,
|
|
A12 a12,
|
|
A13 a13,
|
|
A14 a14,
|
|
A15 a15) {
|
|
return std_bndr_obj_1_2_4_5_6_7_8_9_10_11_12_13_14_15<Function>(static_cast<Function::object_type&>(oi), f, Function::first_argument_type(a1), Function::second_argument_type(a2), Function::argument_4_type(a4), Function::argument_5_type(a5), Function::argument_6_type(a6), Function::argument_7_type(a7), Function::argument_8_type(a8), Function::argument_9_type(a9), Function::argument_10_type(a10), Function::argument_11_type(a11), Function::argument_12_type(a12), Function::argument_13_type(a13), Function::argument_14_type(a14), Function::argument_15_type(a15));
|
|
};
|