156 lines
4.2 KiB
C++
156 lines
4.2 KiB
C++
/*//////////////////////////////////////////////////////////////////////////////
|
|
// CMT Cosmic Muon Tomography project //////////////////////////////////////////
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
|
|
All rights reserved
|
|
|
|
Authors: Andrea Rigoni Garola < andrea.rigoni@pd.infn.it >
|
|
|
|
------------------------------------------------------------------
|
|
This library is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU Lesser General Public
|
|
License as published by the Free Software Foundation; either
|
|
version 3.0 of the License, or (at your option) any later version.
|
|
|
|
This library is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public
|
|
License along with this library.
|
|
|
|
//////////////////////////////////////////////////////////////////////////////*/
|
|
|
|
|
|
|
|
#ifndef U_CORE_FUNCTION_H
|
|
#define U_CORE_FUNCTION_H
|
|
|
|
#include <typeinfo>
|
|
|
|
#include <boost/type_traits.hpp>
|
|
#include <boost/type_traits/remove_pointer.hpp>
|
|
|
|
#include <boost/function_types/function_type.hpp>
|
|
#include <boost/function_types/parameter_types.hpp>
|
|
#include <boost/function_types/function_arity.hpp>
|
|
//#include <boost/typeof/std/utility.hpp>
|
|
|
|
|
|
namespace uLib {
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// type synthesize ( please read: boost implementation synthesize.hpp ) //
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// TODO: change this to boost implementation //
|
|
// return a reference to function ... as the boost signal signature wants
|
|
|
|
template <typename FuncT>
|
|
struct FunctionTypes {};
|
|
|
|
template <typename R, class O>
|
|
struct FunctionTypes< R(O::*)() > {
|
|
typedef R ref();
|
|
typedef R (ptr)();
|
|
typedef O obj;
|
|
};
|
|
|
|
template <typename R, class O, typename T0>
|
|
struct FunctionTypes< R(O::*)(T0) > {
|
|
typedef R ref(T0);
|
|
typedef R (ptr)(T0);
|
|
typedef O obj;
|
|
};
|
|
|
|
template <typename R, class O, typename T0, typename T1>
|
|
struct FunctionTypes< R(O::*)(T0,T1) > {
|
|
typedef R ref(T0,T1);
|
|
typedef R (ptr)(T0,T1);
|
|
typedef O obj;
|
|
};
|
|
|
|
template <typename R, class O, typename T0, typename T1, typename T2>
|
|
struct FunctionTypes< R(O::*)(T0,T1,T2) > {
|
|
typedef R ref(T0,T1,T2);
|
|
typedef R (ptr)(T0,T1,T2);
|
|
typedef O obj;
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// Function pointers //
|
|
|
|
template<typename Func>
|
|
struct FunctionPointer {
|
|
typedef typename boost::function_types::function_type<Func>::type Signature;
|
|
typedef typename FunctionTypes<Func>::ref SignalSignature;
|
|
enum {
|
|
arity = boost::function_types::function_arity<Func>::value,
|
|
ismfp = boost::is_member_function_pointer<Func>::value
|
|
};
|
|
|
|
typedef boost::mpl::bool_< ismfp > HasObjectType;
|
|
typedef typename FunctionTypes<Func>::obj Object;
|
|
typedef boost::function_traits< Signature > Traits;
|
|
|
|
virtual void PrintSelf( std::ostream &o ) {
|
|
o << "[fp: " << typeid(Signature).name()
|
|
<< " arity: " << arity << "]\n"; }
|
|
};
|
|
|
|
|
|
|
|
|
|
//////// generic mfp container object /////////////////////////////////////////
|
|
|
|
class GenericMFPtr {
|
|
typedef void (GenericMFPtr::*_MFPtrStub_t)();
|
|
public:
|
|
|
|
typedef _MFPtrStub_t Type;
|
|
|
|
GenericMFPtr() {}
|
|
|
|
template <typename T>
|
|
GenericMFPtr(T in) {
|
|
m_ptr = reinterpret_cast<_MFPtrStub_t>(in);
|
|
}
|
|
|
|
template <typename T>
|
|
inline bool operator == (T in) {
|
|
return m_ptr == reinterpret_cast<_MFPtrStub_t>(in);
|
|
}
|
|
|
|
inline bool operator == (const GenericMFPtr &in) {
|
|
return m_ptr == in.m_ptr;
|
|
}
|
|
|
|
Type operator()() { return m_ptr; }
|
|
|
|
_MFPtrStub_t m_ptr;
|
|
private:
|
|
};
|
|
|
|
} // uLib
|
|
|
|
|
|
|
|
|
|
#endif // FUNCTION_H
|