Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-05-30 09:33:05 +03:00
Code Issues Actions Packages Projects Releases Wiki Activity

(nw) So we're back to MSVC blowing up on non-trivial templates. Lovely.

Browse Source 
Someone needs to get MS QA to put some non-trivial modern C++
compliation tests in the acceptance tests for their C++ compiler.  Maybe
MAME could even be a candidate.  Well, that might be a plan if MS still
had any QA.  At least this makes some lines shorter (at the cost of
needing more lines).
This commit is contained in:
Vas Crabb 2018-12-30 17:32:13 +11:00
parent 11936fbafd
commit 8ef80b186b
2 changed files with 18 additions and 10 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
src/emu/devdelegate.h
View File

@ -42,11 +42,15 @@ protected:
template <typename Signature>
class named_delegate : public delegate<Signature>
{
protected:
private:
using basetype = delegate<Signature>;
template <class FunctionClass> using member_func_type = typename basetype::template traits<FunctionClass>::member_func_type;
template <class FunctionClass> using const_member_func_type = typename basetype::template traits<FunctionClass>::const_member_func_type;
template <class FunctionClass> using static_ref_func_type = typename basetype::template traits<FunctionClass>::static_ref_func_type;
const char * m_name; // name string
protected:
template <class FunctionClass> using member_func_type = typename basetype::template member_func_type<FunctionClass>;
template <class FunctionClass> using const_member_func_type = typename basetype::template const_member_func_type<FunctionClass>;
template <class FunctionClass> using static_ref_func_type = typename basetype::template static_ref_func_type<FunctionClass>;
public:
// create a standard set of constructors
@ -60,9 +64,6 @@ public:
named_delegate &operator=(const basetype &src) { basetype::operator=(src); m_name = src.m_name; return *this; }
const char *name() const { return m_name; }
private:
const char * m_name; // name string
};
// ======================> device_delegate

13
src/lib/util/delegate.h
View File

@ -591,17 +591,24 @@ class delegate;
template <typename ReturnType, typename... Params>
class delegate<ReturnType (Params...)> : public delegate_base<ReturnType, Params...>
{
private:
using basetype = delegate_base<ReturnType, Params...>;
protected:
template <class FunctionClass> using traits = typename basetype::template traits<FunctionClass>;
template <class FunctionClass> using member_func_type = typename traits<FunctionClass>::member_func_type;
template <class FunctionClass> using const_member_func_type = typename traits<FunctionClass>::const_member_func_type;
template <class FunctionClass> using static_ref_func_type = typename traits<FunctionClass>::static_ref_func_type;
public:
// create a standard set of constructors
delegate() : basetype() { }
explicit delegate(const basetype &src) : basetype(src) { }
delegate(const basetype &src, delegate_late_bind &object) : basetype(src, object) { }
template <class FunctionClass> delegate(typename basetype::template traits<FunctionClass>::member_func_type funcptr, FunctionClass *object) : basetype(funcptr, object) { }
template <class FunctionClass> delegate(typename basetype::template traits<FunctionClass>::const_member_func_type funcptr, FunctionClass *object) : basetype(funcptr, object) { }
template <class FunctionClass> delegate(member_func_type<FunctionClass> funcptr, FunctionClass *object) : basetype(funcptr, object) { }
template <class FunctionClass> delegate(const_member_func_type<FunctionClass> funcptr, FunctionClass *object) : basetype(funcptr, object) { }
explicit delegate(std::function<ReturnType (Params...)> funcptr) : basetype(funcptr) { }
template <class FunctionClass> delegate(typename basetype::template traits<FunctionClass>::static_ref_func_type funcptr, FunctionClass *object) : basetype(funcptr, object) { }
template <class FunctionClass> delegate(static_ref_func_type<FunctionClass> funcptr, FunctionClass *object) : basetype(funcptr, object) { }
delegate &operator=(const basetype &src) { *static_cast<basetype *>(this) = src; return *this; }
};