ba50ac6da2
git-svn-id: svn://svn.code.sf.net/p/loki-lib/code/trunk@101 7ec92016-0320-0410-acc4-a06ded1c099a
784 lines
26 KiB
C++
784 lines
26 KiB
C++
////////////////////////////////////////////////////////////////////////////////
|
|
// The Loki Library
|
|
// Copyright (c) 2001 by Andrei Alexandrescu
|
|
// This code accompanies the book:
|
|
// Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design
|
|
// Patterns Applied". Copyright (c) 2001. Addison-Wesley.
|
|
// Permission to use, copy, modify, distribute and sell this software for any
|
|
// purpose is hereby granted without fee, provided that the above copyright
|
|
// notice appear in all copies and that both that copyright notice and this
|
|
// permission notice appear in supporting documentation.
|
|
// The author or Addison-Welsey Longman make no representations about the
|
|
// suitability of this software for any purpose. It is provided "as is"
|
|
// without express or implied warranty.
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// Last update: Feb 19, 2003
|
|
// All dispatchers now support void as return type.
|
|
//
|
|
//
|
|
// The port now uses Tye2Type-parameters instead of plain pointers as
|
|
// a workaround of VC's explicit template argument specification bug.
|
|
//
|
|
// For example:
|
|
// The original declaration of BasicDispatcher::Add looks like this:
|
|
//
|
|
// template <class SomeLhs, class SomeRhs>
|
|
// void Add(CallbackType fun);
|
|
//
|
|
// and you call it like this:
|
|
// obj.Add<Type1, Type2>(yourFun);
|
|
//
|
|
// This port uses:
|
|
//
|
|
// template <class SomeLhs, class SomeRhs>
|
|
// void Add(CallbackType fun, Type2Type<SomeLhs>, Type2Type<SomeRhs>);
|
|
//
|
|
// and you call it like this:
|
|
// obj.Add(yourFun, Type2Type<Type1>(), Type2Type<Type2>());
|
|
|
|
|
|
#ifndef MULTIMETHODS_INC_
|
|
#define MULTIMETHODS_INC_
|
|
|
|
#include "Typelist.h"
|
|
#include "TypeInfo.h"
|
|
#include "Functor.h"
|
|
#include "AssocVector.h"
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// IMPORTANT NOTE:
|
|
// The double dispatchers implemented below differ from the excerpts shown in
|
|
// the book - they are simpler while respecting the same interface.
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
namespace Loki
|
|
{
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// Implementation helpers for StaticDispatcher
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
namespace Private
|
|
{
|
|
template <class SomeLhs, class SomeRhs,
|
|
class Executor, typename ResultType>
|
|
struct InvocationTraits
|
|
{
|
|
static ResultType
|
|
DoDispatch(SomeLhs& lhs, SomeRhs& rhs, Executor& exec, Int2Type<false>)
|
|
{
|
|
return exec.Fire(lhs, rhs);
|
|
}
|
|
static ResultType DoDispatch( SomeLhs& lhs, SomeRhs& rhs,
|
|
Executor& exec, Int2Type<true>)
|
|
{
|
|
return exec.Fire(rhs, lhs);
|
|
}
|
|
};
|
|
|
|
template <class SomeLhs, class SomeRhs, class Executor>
|
|
struct InvocationTraitsVoid
|
|
{
|
|
typedef void ResultType;
|
|
static ResultType
|
|
DoDispatch(SomeLhs& lhs, SomeRhs& rhs, Executor& exec, Int2Type<false>)
|
|
{
|
|
exec.Fire(lhs, rhs);
|
|
}
|
|
static ResultType DoDispatch( SomeLhs& lhs, SomeRhs& rhs,
|
|
Executor& exec, Int2Type<true>)
|
|
{
|
|
exec.Fire(rhs, lhs);
|
|
}
|
|
};
|
|
|
|
// Implementation for StaticDispatcher with result type != void
|
|
template<class Executor, class BaseLhs, class TypesLhs, bool symmetric,
|
|
class BaseRhs, class TypesRhs, typename ResultType>
|
|
class StaticDispatcherBase
|
|
{
|
|
template <class SomeLhs>
|
|
static ResultType DispatchRhs( SomeLhs& lhs, BaseRhs& rhs,
|
|
Executor exec, NullType)
|
|
{ return exec.OnError(lhs, rhs); }
|
|
|
|
template <class Head, class Tail, class SomeLhs>
|
|
static ResultType DispatchRhs(SomeLhs& lhs, BaseRhs& rhs,
|
|
Executor exec, Typelist<Head, Tail>)
|
|
{
|
|
if (Head* p2 = dynamic_cast<Head*>(&rhs))
|
|
{
|
|
Int2Type<(symmetric &&
|
|
int(TL::IndexOf<TypesRhs, Head>::value) <
|
|
int(TL::IndexOf<TypesLhs, SomeLhs>::value))> i2t;
|
|
|
|
typedef Private::InvocationTraits<
|
|
SomeLhs, Head, Executor, ResultType> CallTraits;
|
|
|
|
return CallTraits::DoDispatch(lhs, *p2, exec, i2t);
|
|
}
|
|
return DispatchRhs(lhs, rhs, exec, Tail());
|
|
}
|
|
|
|
static ResultType DispatchLhs( BaseLhs& lhs, BaseRhs& rhs,
|
|
Executor exec, NullType)
|
|
{ return exec.OnError(lhs, rhs); }
|
|
|
|
template <class Head, class Tail>
|
|
static ResultType DispatchLhs( BaseLhs& lhs, BaseRhs& rhs,
|
|
Executor exec, Typelist<Head, Tail>)
|
|
{
|
|
if (Head* p1 = dynamic_cast<Head*>(&lhs))
|
|
{
|
|
return DispatchRhs(*p1, rhs, exec, TypesRhs());
|
|
}
|
|
return DispatchLhs(lhs, rhs, exec, Tail());
|
|
}
|
|
|
|
public:
|
|
static ResultType Go( BaseLhs& lhs, BaseRhs& rhs,
|
|
Executor exec)
|
|
{ return DispatchLhs(lhs, rhs, exec, TypesLhs()); }
|
|
};
|
|
|
|
// Implementation for StaticDispatcher with result type = void
|
|
template<class Executor, class BaseLhs, class TypesLhs, bool symmetric,
|
|
class BaseRhs, class TypesRhs>
|
|
class StaticDispatcherVoidBase
|
|
{
|
|
typedef void ResultType;
|
|
template <class SomeLhs>
|
|
static ResultType DispatchRhs( SomeLhs& lhs, BaseRhs& rhs,
|
|
Executor exec, NullType)
|
|
{ exec.OnError(lhs, rhs); }
|
|
|
|
template <class Head, class Tail, class SomeLhs>
|
|
static ResultType DispatchRhs(SomeLhs& lhs, BaseRhs& rhs,
|
|
Executor exec, Typelist<Head, Tail>)
|
|
{
|
|
if (Head* p2 = dynamic_cast<Head*>(&rhs))
|
|
{
|
|
Int2Type<(symmetric &&
|
|
int(TL::IndexOf<TypesRhs, Head>::value) <
|
|
int(TL::IndexOf<TypesLhs, SomeLhs>::value))> i2t;
|
|
|
|
typedef Private::InvocationTraitsVoid<
|
|
SomeLhs, Head, Executor> CallTraits;
|
|
|
|
CallTraits::DoDispatch(lhs, *p2, exec, i2t);
|
|
return;
|
|
}
|
|
DispatchRhs(lhs, rhs, exec, Tail());
|
|
}
|
|
|
|
static ResultType DispatchLhs( BaseLhs& lhs, BaseRhs& rhs,
|
|
Executor exec, NullType)
|
|
{ exec.OnError(lhs, rhs); }
|
|
|
|
template <class Head, class Tail>
|
|
static ResultType DispatchLhs( BaseLhs& lhs, BaseRhs& rhs,
|
|
Executor exec, Typelist<Head, Tail>)
|
|
{
|
|
if (Head* p1 = dynamic_cast<Head*>(&lhs))
|
|
{
|
|
DispatchRhs(*p1, rhs, exec, TypesRhs());
|
|
return;
|
|
}
|
|
DispatchLhs(lhs, rhs, exec, Tail());
|
|
}
|
|
|
|
public:
|
|
static ResultType Go( BaseLhs& lhs, BaseRhs& rhs,
|
|
Executor exec)
|
|
{ DispatchLhs(lhs, rhs, exec, TypesLhs()); }
|
|
};
|
|
|
|
} // namespace Private
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// class template StaticDispatcher
|
|
// Implements an automatic static double dispatcher based on two typelists
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
template
|
|
<
|
|
class Executor,
|
|
class BaseLhs,
|
|
class TypesLhs,
|
|
bool symmetric = true,
|
|
class BaseRhs = BaseLhs,
|
|
class TypesRhs = TypesLhs,
|
|
typename ResultType = int
|
|
>
|
|
class StaticDispatcher : public ::Loki::Select
|
|
<
|
|
::Loki::Private::IsVoid<ResultType>::value,
|
|
::Loki::Private::StaticDispatcherVoidBase<Executor,
|
|
BaseLhs, TypesLhs, symmetric, BaseRhs,
|
|
TypesRhs>,
|
|
::Loki::Private::StaticDispatcherBase<Executor,
|
|
BaseLhs, TypesLhs, symmetric, BaseRhs,
|
|
TypesRhs, ResultType>
|
|
>::Result
|
|
{
|
|
|
|
public:
|
|
// member functions moved to base class
|
|
// static ResultType Go( BaseLhs& lhs, BaseRhs& rhs,
|
|
// Executor exec)
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// Implementation helpers for BasicDispatcher
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
namespace Private
|
|
{
|
|
// Implementation for result types != void
|
|
template <class BaseLhs, class BaseRhs, typename ResultType,
|
|
typename CallbackType> struct BasicDispatcherBase;
|
|
|
|
// Implementation for result type = 0
|
|
template <class BaseLhs, class BaseRhs,
|
|
typename CallbackType> struct BasicDispatcherVoidBase;
|
|
|
|
// Common (independent of the result type) code for BasicDispatcher
|
|
template<typename CallbackType>
|
|
class BasicDispatcherCommonBase
|
|
{
|
|
private:
|
|
void DoAdd(TypeInfo lhs, TypeInfo rhs, CallbackType fun);
|
|
bool DoRemove(TypeInfo lhs, TypeInfo rhs);
|
|
protected:
|
|
typedef std::pair<TypeInfo,TypeInfo> KeyType;
|
|
typedef CallbackType MappedType;
|
|
typedef AssocVector<KeyType, MappedType> MapType;
|
|
MapType callbackMap_;
|
|
public:
|
|
template <class SomeLhs, class SomeRhs>
|
|
void Add(CallbackType fun, ::Loki::Type2Type<SomeLhs>,
|
|
::Loki::Type2Type<SomeRhs>)
|
|
{
|
|
DoAdd(typeid(SomeLhs), typeid(SomeRhs), fun);
|
|
}
|
|
|
|
|
|
template <class SomeLhs, class SomeRhs>
|
|
bool Remove(::Loki::Type2Type<SomeLhs>, ::Loki::Type2Type<SomeRhs>)
|
|
{
|
|
return DoRemove(typeid(SomeLhs), typeid(SomeRhs));
|
|
}
|
|
|
|
};
|
|
|
|
// Non-inline to reduce compile time overhead...
|
|
template <typename CallbackType>
|
|
void BasicDispatcherCommonBase<CallbackType>
|
|
::DoAdd(TypeInfo lhs, TypeInfo rhs, CallbackType fun)
|
|
{
|
|
callbackMap_[KeyType(lhs, rhs)] = fun;
|
|
}
|
|
|
|
template <typename CallbackType>
|
|
bool BasicDispatcherCommonBase<CallbackType>
|
|
::DoRemove(TypeInfo lhs, TypeInfo rhs)
|
|
{
|
|
return callbackMap_.erase(KeyType(lhs, rhs)) == 1;
|
|
}
|
|
|
|
// Implementation for result types != void
|
|
template <class BaseLhs, class BaseRhs, typename ResultType,
|
|
typename CallbackType>
|
|
struct BasicDispatcherBase : public BasicDispatcherCommonBase<CallbackType>
|
|
{
|
|
typedef BasicDispatcherCommonBase<CallbackType> Base;
|
|
|
|
ResultType Go(BaseLhs& lhs, BaseRhs& rhs);
|
|
};
|
|
template <class BaseLhs, class BaseRhs,
|
|
typename ResultType, typename CallbackType>
|
|
ResultType
|
|
BasicDispatcherBase<BaseLhs,BaseRhs,ResultType,CallbackType>
|
|
::Go(BaseLhs& lhs, BaseRhs& rhs)
|
|
{
|
|
|
|
typename MapType::key_type k(typeid(lhs),typeid(rhs));
|
|
typename MapType::iterator i = Base::callbackMap_.find(k);
|
|
if (i == Base::callbackMap_.end())
|
|
{
|
|
throw std::runtime_error("Function not found");
|
|
}
|
|
return (i->second)(lhs, rhs);
|
|
}
|
|
|
|
// Implementation for result types = void
|
|
template <class BaseLhs, class BaseRhs, typename CallbackType>
|
|
struct BasicDispatcherVoidBase : public BasicDispatcherCommonBase<CallbackType>
|
|
{
|
|
typedef void ResultType;
|
|
typedef BasicDispatcherCommonBase<CallbackType> Base;
|
|
|
|
ResultType Go(BaseLhs& lhs, BaseRhs& rhs);
|
|
};
|
|
template <class BaseLhs, class BaseRhs, typename CallbackType>
|
|
typename BasicDispatcherVoidBase<BaseLhs,BaseRhs, CallbackType>::ResultType
|
|
BasicDispatcherVoidBase<BaseLhs,BaseRhs, CallbackType>
|
|
::Go(BaseLhs& lhs, BaseRhs& rhs)
|
|
{
|
|
|
|
typename MapType::key_type k(typeid(lhs),typeid(rhs));
|
|
typename MapType::iterator i = Base::callbackMap_.find(k);
|
|
if (i == Base::callbackMap_.end())
|
|
{
|
|
throw std::runtime_error("Function not found");
|
|
}
|
|
(i->second)(lhs, rhs);
|
|
}
|
|
} // namespace Private
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// class template BasicDispatcher
|
|
// Implements a logarithmic double dispatcher for functors (or functions)
|
|
// Doesn't offer automated casts or symmetry
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
template
|
|
<
|
|
class BaseLhs,
|
|
class BaseRhs = BaseLhs,
|
|
typename ResultType = int,
|
|
typename CallbackType = ResultType (*)(BaseLhs&, BaseRhs&)
|
|
>
|
|
class BasicDispatcher : public ::Loki::Select
|
|
<
|
|
::Loki::Private::IsVoid<ResultType>::value,
|
|
::Loki::Private::BasicDispatcherVoidBase<
|
|
BaseLhs, BaseRhs, CallbackType>,
|
|
::Loki::Private::BasicDispatcherBase<
|
|
BaseLhs, BaseRhs, ResultType, CallbackType>
|
|
>::Result
|
|
{
|
|
public:
|
|
// member functions moved to base class
|
|
// template <class SomeLhs, class SomeRhs>
|
|
// void Add(CallbackType fun, ::Loki::Type2Type<SomeLhs>,
|
|
// ::Loki::Type2Type<SomeRhs>)
|
|
//
|
|
// template <class SomeLhs, class SomeRhs>
|
|
// bool Remove(::Loki::Type2Type<SomeLhs>, ::Loki::Type2Type<SomeRhs>)
|
|
//
|
|
// ResultType Go(BaseLhs& lhs, BaseRhs& rhs);
|
|
};
|
|
|
|
|
|
struct BasicDispatcherWrapper
|
|
{
|
|
template <class T, class U, class V, class W>
|
|
struct In
|
|
{
|
|
typedef BasicDispatcher<T, U, V, W> type;
|
|
};
|
|
};
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// class template StaticCaster
|
|
// Implementation of the CastingPolicy used by FunctorDispatcher
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
template <class To, class From>
|
|
struct StaticCaster
|
|
{
|
|
static To& Cast(From& obj)
|
|
{
|
|
return static_cast<To&>(obj);
|
|
}
|
|
};
|
|
struct StaticCasterWrapper
|
|
{
|
|
template <class T, class U>
|
|
struct In
|
|
{
|
|
typedef StaticCaster<T, U> type;
|
|
};
|
|
};
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// class template DynamicCaster
|
|
// Implementation of the CastingPolicy used by FunctorDispatcher
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
template <class To, class From>
|
|
struct DynamicCaster
|
|
{
|
|
static To& Cast(From& obj)
|
|
{
|
|
return dynamic_cast<To&>(obj);
|
|
}
|
|
};
|
|
struct DynamicCasterWrapper
|
|
{
|
|
template <class T, class U>
|
|
struct In
|
|
{
|
|
typedef DynamicCaster<T, U> type;
|
|
};
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// class template Private::FnDispatcherHelper
|
|
// Implements trampolines and argument swapping used by FnDispatcher
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
namespace Private
|
|
{
|
|
template <typename ResultType, class BaseLhs, class BaseRhs,
|
|
class DispatcherBackend>
|
|
struct FnDispatcherBase
|
|
{
|
|
ApplyInnerType4<DispatcherBackend, BaseLhs, BaseRhs, ResultType,
|
|
ResultType (*)(BaseLhs&, BaseRhs&)>::type backEnd_;
|
|
|
|
ResultType Go(BaseLhs& lhs, BaseRhs& rhs)
|
|
{
|
|
return backEnd_.Go(lhs, rhs);
|
|
}
|
|
};
|
|
|
|
template <class BaseLhs, class BaseRhs, class DispatcherBackend>
|
|
struct FnDispatcherVoidBase
|
|
{
|
|
typedef void ResultType;
|
|
ApplyInnerType4<DispatcherBackend, BaseLhs, BaseRhs, ResultType,
|
|
ResultType (*)(BaseLhs&, BaseRhs&)>::type backEnd_;
|
|
|
|
ResultType Go(BaseLhs& lhs, BaseRhs& rhs)
|
|
{
|
|
backEnd_.Go(lhs, rhs);
|
|
}
|
|
};
|
|
|
|
|
|
template< class BaseLhs, class BaseRhs, class SomeLhs, class SomeRhs,
|
|
class CastLhs, class CastRhs,
|
|
void (*Callback)(SomeLhs&, SomeRhs&)>
|
|
struct FnDispatcherHelperVoidBase
|
|
{
|
|
typedef void ResultType;
|
|
static ResultType Trampoline(BaseLhs& lhs, BaseRhs& rhs)
|
|
{
|
|
Callback(CastLhs::Cast(lhs), CastRhs::Cast(rhs));
|
|
}
|
|
static ResultType TrampolineR(BaseRhs& rhs, BaseLhs& lhs)
|
|
{
|
|
Trampoline(lhs, rhs);
|
|
}
|
|
};
|
|
|
|
template<typename ResultType, class BaseLhs, class BaseRhs,
|
|
class SomeLhs, class SomeRhs, class CastLhs, class CastRhs,
|
|
ResultType (*Callback)(SomeLhs&, SomeRhs&)>
|
|
struct FnDispatcherHelperBase
|
|
{
|
|
typedef void ResultType;
|
|
static ResultType Trampoline(BaseLhs& lhs, BaseRhs& rhs)
|
|
{
|
|
Callback(CastLhs::Cast(lhs), CastRhs::Cast(rhs));
|
|
}
|
|
static ResultType TrampolineR(BaseRhs& rhs, BaseLhs& lhs)
|
|
{
|
|
Trampoline(lhs, rhs);
|
|
}
|
|
};
|
|
|
|
template
|
|
<
|
|
class BaseLhs, class BaseRhs, class SomeLhs, class SomeRhs,
|
|
typename ResultType, class CastLhs, class CastRhs,
|
|
ResultType (*Callback)(SomeLhs&, SomeRhs&)
|
|
>
|
|
struct FnDispatcherHelper : public ::Loki::Select
|
|
<
|
|
::Loki::Private::IsVoid<ResultType>::value,
|
|
FnDispatcherHelperVoidBase<BaseLhs, BaseRhs,
|
|
SomeLhs, SomeRhs, CastLhs, CastRhs,
|
|
Callback>,
|
|
FnDispatcherHelperBase<ResultType, BaseLhs, BaseRhs,
|
|
SomeLhs, SomeRhs, CastLhs, CastRhs,
|
|
Callback>
|
|
>::Result
|
|
{};
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// class template FnDispatcher
|
|
// Implements an automatic logarithmic double dispatcher for functions
|
|
// Features automated conversions
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
template <class BaseLhs, class BaseRhs = BaseLhs,
|
|
typename ResultType = int/*void*/,
|
|
class CastingPolicy = DynamicCasterWrapper,
|
|
class DispatcherBackend = BasicDispatcherWrapper>
|
|
class FnDispatcher : public ::Loki::Select
|
|
<
|
|
::Loki::Private::IsVoid<ResultType>::value,
|
|
::Loki::Private::FnDispatcherVoidBase<BaseLhs,
|
|
BaseRhs, DispatcherBackend>,
|
|
::Loki::Private::FnDispatcherBase<ResultType, BaseLhs,
|
|
BaseRhs, DispatcherBackend>
|
|
>::Result
|
|
{
|
|
typedef typename ::Loki::Select
|
|
<::Loki::Private::IsVoid<ResultType>::value,
|
|
::Loki::Private::FnDispatcherVoidBase<BaseLhs,
|
|
BaseRhs, DispatcherBackend>,
|
|
::Loki::Private::FnDispatcherBase<ResultType, BaseLhs,
|
|
BaseRhs, DispatcherBackend>
|
|
>::Result Base;
|
|
|
|
public:
|
|
template <class SomeLhs, class SomeRhs>
|
|
void Add(ResultType (*pFun)(BaseLhs&, BaseRhs&),
|
|
::Loki::Type2Type<SomeLhs>,
|
|
::Loki::Type2Type<SomeRhs>)
|
|
{
|
|
Base::backEnd_.Add(pFun, ::Loki::Type2Type<SomeLhs>(),
|
|
::Loki::Type2Type<SomeRhs>());
|
|
}
|
|
|
|
template <class SomeLhs, class SomeRhs,
|
|
ResultType (*callback)(SomeLhs&, SomeRhs&)>
|
|
void Add(::Loki::Type2Type<SomeLhs>, ::Loki::Type2Type<SomeRhs>)
|
|
{
|
|
typedef Private::FnDispatcherHelper<
|
|
BaseLhs, BaseRhs,
|
|
SomeLhs, SomeRhs,
|
|
ResultType,
|
|
typename ApplyInnerType2<CastingPolicy, SomeLhs,BaseLhs>::type,
|
|
typename ApplyInnerType2<CastingPolicy,SomeRhs,BaseRhs>::type,
|
|
callback> Local;
|
|
|
|
Add(&Local::Trampoline, ::Loki::Type2Type<SomeLhs>(),
|
|
::Loki::Type2Type<SomeRhs>());
|
|
}
|
|
|
|
template <class SomeLhs, class SomeRhs,
|
|
ResultType (*callback)(SomeLhs&, SomeRhs&)>
|
|
void Add(::Loki::Type2Type<SomeLhs>, ::Loki::Type2Type<SomeRhs>,
|
|
bool Symmetric)
|
|
{
|
|
typedef Private::FnDispatcherHelper<
|
|
BaseLhs, BaseRhs,
|
|
SomeLhs, SomeRhs,
|
|
ResultType,
|
|
typename ApplyInnerType2<CastingPolicy, SomeLhs,BaseLhs>::type,
|
|
typename ApplyInnerType2<CastingPolicy,SomeRhs,BaseRhs>::type,
|
|
callback> Local;
|
|
|
|
Add(&Local::Trampoline, ::Loki::Type2Type<SomeLhs>(),
|
|
::Loki::Type2Type<SomeRhs>());
|
|
if (Symmetric)
|
|
{
|
|
Add(&Local::Trampoline, ::Loki::Type2Type<SomeLhs>(),
|
|
::Loki::Type2Type<SomeRhs>());
|
|
}
|
|
}
|
|
|
|
template <class SomeLhs, class SomeRhs>
|
|
void Remove(::Loki::Type2Type<SomeLhs>, ::Loki::Type2Type<SomeRhs>)
|
|
{
|
|
Base::backEnd_.Remove(::Loki::Type2Type<SomeLhs>(),
|
|
::Loki::Type2Type<SomeRhs>());
|
|
}
|
|
|
|
|
|
// moved to base class
|
|
// ResultType Go(BaseLhs& lhs, BaseRhs& rhs);
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// class template FunctorDispatcherAdaptor
|
|
// permits use of FunctorDispatcher under gcc.2.95.2/3
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
namespace Private
|
|
{
|
|
template <class BaseLhs, class BaseRhs, class SomeLhs, class SomeRhs,
|
|
typename ResultType, class CastLhs, class CastRhs, class Fun, bool SwapArgs>
|
|
class FunctorDispatcherHelper
|
|
{
|
|
Fun fun_;
|
|
ResultType Fire(BaseLhs& lhs, BaseRhs& rhs,Int2Type<false>)
|
|
{
|
|
return fun_(CastLhs::Cast(lhs), CastRhs::Cast(rhs));
|
|
}
|
|
ResultType Fire(BaseLhs& rhs, BaseRhs& lhs,Int2Type<true>)
|
|
{
|
|
return fun_(CastLhs::Cast(lhs), CastRhs::Cast(rhs));
|
|
}
|
|
public:
|
|
FunctorDispatcherHelper(const Fun& fun) : fun_(fun) {}
|
|
|
|
ResultType operator()(BaseLhs& lhs, BaseRhs& rhs)
|
|
{
|
|
return Fire(lhs,rhs,Int2Type<SwapArgs>());
|
|
}
|
|
};
|
|
|
|
template <class BaseLhs, class BaseRhs, class SomeLhs, class SomeRhs,
|
|
class CastLhs, class CastRhs, class Fun, bool SwapArgs>
|
|
class FunctorDispatcherHelperVoid
|
|
{
|
|
Fun fun_;
|
|
typedef void ResultType;
|
|
ResultType Fire(BaseLhs& lhs, BaseRhs& rhs,Int2Type<false>)
|
|
{
|
|
fun_(CastLhs::Cast(lhs), CastRhs::Cast(rhs));
|
|
}
|
|
ResultType Fire(BaseLhs& rhs, BaseRhs& lhs,Int2Type<true>)
|
|
{
|
|
fun_(CastLhs::Cast(lhs), CastRhs::Cast(rhs));
|
|
}
|
|
public:
|
|
FunctorDispatcherHelperVoid(const Fun& fun) : fun_(fun) {}
|
|
|
|
ResultType operator()(BaseLhs& lhs, BaseRhs& rhs)
|
|
{
|
|
Fire(lhs,rhs,Int2Type<SwapArgs>());
|
|
}
|
|
};
|
|
|
|
template <class BaseLhs, class BaseRhs, typename ResultType,
|
|
class DispatcherBackend>
|
|
class FunctorDispatcherCommonBase
|
|
{
|
|
protected:
|
|
typedef TYPELIST_2(BaseLhs&, BaseRhs&) ArgsList;
|
|
typedef Functor<ResultType, ArgsList, DEFAULT_THREADING> FunctorType;
|
|
|
|
ApplyInnerType4<DispatcherBackend,BaseLhs, BaseRhs, ResultType,
|
|
FunctorType>::type backEnd_;
|
|
};
|
|
|
|
template <typename ResultType, class BaseLhs, class BaseRhs,
|
|
class DispatcherBackend>
|
|
class FunctorDispatcherBase : public FunctorDispatcherCommonBase<BaseLhs,
|
|
BaseRhs, ResultType, DispatcherBackend>
|
|
{
|
|
typedef FunctorDispatcherCommonBase<BaseLhs, BaseRhs, ResultType,
|
|
DispatcherBackend> Base;
|
|
public:
|
|
typedef typename Base::ArgsList ArgsList;
|
|
typedef typename Base::FunctorType FunctorType;
|
|
|
|
ResultType Go(BaseLhs& lhs, BaseRhs& rhs)
|
|
{
|
|
return Base::backEnd_.Go(lhs, rhs);
|
|
}
|
|
};
|
|
|
|
template <class BaseLhs, class BaseRhs, class DispatcherBackend>
|
|
class FunctorDispatcherVoidBase : public FunctorDispatcherCommonBase<BaseLhs,
|
|
BaseRhs, void, DispatcherBackend>
|
|
{
|
|
typedef void ResultType;
|
|
typedef FunctorDispatcherCommonBase<BaseLhs, BaseRhs, ResultType,
|
|
DispatcherBackend> Base;
|
|
public:
|
|
typedef typename Base::ArgsList ArgsList;
|
|
typedef typename Base::FunctorType FunctorType;
|
|
|
|
ResultType Go(BaseLhs& lhs, BaseRhs& rhs)
|
|
{
|
|
Base::backEnd_.Go(lhs, rhs);
|
|
}
|
|
|
|
};
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// class template FunctorDispatcher
|
|
// Implements a logarithmic double dispatcher for functors
|
|
// Features automated casting
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
template <class BaseLhs, class BaseRhs = BaseLhs,
|
|
typename ResultType = int/*void*/,
|
|
class CastingPolicy = DynamicCasterWrapper,
|
|
class DispatcherBackend = BasicDispatcherWrapper>
|
|
class FunctorDispatcher : public ::Loki::Select
|
|
<
|
|
::Loki::Private::IsVoid<ResultType>::value,
|
|
::Loki::Private::FunctorDispatcherVoidBase<BaseLhs,
|
|
BaseRhs, DispatcherBackend>,
|
|
::Loki::Private::FunctorDispatcherBase<ResultType,
|
|
BaseLhs, BaseRhs, DispatcherBackend>
|
|
>::Result
|
|
{
|
|
typedef typename ::Loki::Select
|
|
<
|
|
::Loki::Private::IsVoid<ResultType>::value,
|
|
::Loki::Private::FunctorDispatcherVoidBase<BaseLhs, BaseRhs,
|
|
DispatcherBackend>,
|
|
::Loki::Private::FunctorDispatcherBase<ResultType, BaseLhs, BaseRhs,
|
|
DispatcherBackend>
|
|
>::Result Base;
|
|
public:
|
|
typedef Base::ArgsList ArgsList;
|
|
typedef Base::FunctorType FunctorType;
|
|
template <class SomeLhs, class SomeRhs, class Fun>
|
|
void Add(const Fun& fun, ::Loki::Type2Type<SomeLhs>,
|
|
::Loki::Type2Type<SomeRhs>)
|
|
{
|
|
typedef typename ApplyInnerType2<CastingPolicy,SomeLhs, BaseLhs>::type CastOne;
|
|
typedef typename ApplyInnerType2<CastingPolicy,SomeRhs, BaseRhs>::type CastTwo;
|
|
typedef typename Select<
|
|
Private::IsVoid<ResultType>::value,
|
|
Private::FunctorDispatcherHelperVoid<BaseLhs, BaseRhs, SomeLhs,
|
|
SomeRhs, CastOne,CastTwo,Fun, false>,
|
|
Private::FunctorDispatcherHelper<BaseLhs, BaseRhs, SomeLhs, SomeRhs,
|
|
ResultType,CastOne,CastTwo,Fun, false>
|
|
>::Result Adapter;
|
|
Base::backEnd_.Add(FunctorType(Adapter(fun), Loki::Disambiguate()),
|
|
Type2Type<SomeLhs>(), Type2Type<SomeRhs>());
|
|
}
|
|
template <class SomeLhs, class SomeRhs, class Fun>
|
|
void Add(const Fun& fun, ::Loki::Type2Type<SomeLhs>,
|
|
::Loki::Type2Type<SomeRhs>, bool symmetric)
|
|
{
|
|
Add(fun, Type2Type<SomeLhs>(), Type2Type<SomeRhs>());
|
|
|
|
if (symmetric)
|
|
{
|
|
// Note: symmetry only makes sense where BaseLhs==BaseRhs
|
|
typedef typename ApplyInnerType2<CastingPolicy,SomeLhs, BaseLhs>::type CastOne;
|
|
typedef typename ApplyInnerType2<CastingPolicy,SomeRhs, BaseLhs>::type CastTwo;
|
|
typedef typename Select<Private::IsVoid<ResultType>::value,
|
|
Private::FunctorDispatcherHelperVoid<BaseLhs, BaseLhs,
|
|
SomeLhs, SomeRhs, CastOne,CastTwo, Fun, true>,
|
|
Private::FunctorDispatcherHelper<BaseLhs, BaseLhs,
|
|
ResultType, SomeLhs, SomeRhs,CastOne, CastTwo,Fun, true>
|
|
>::Result AdapterR;
|
|
|
|
Base::backEnd_.Add(FunctorType(Adapter(fun)),
|
|
Type2Type<SomeLhs>(), Type2Type<SomeRhs>());
|
|
}
|
|
}
|
|
|
|
template <class SomeLhs, class SomeRhs>
|
|
void Remove(::Loki::Type2Type<SomeLhs>, ::Loki::Type2Type<SomeRhs>)
|
|
{
|
|
Base::backEnd_.Remove(Type2Type<SomeLhs>(), Type2Type<SomeRhs>());
|
|
}
|
|
|
|
// moved to base class
|
|
// ResultType Go(BaseLhs& lhs, BaseRhs& rhs);
|
|
|
|
};
|
|
} // namespace Loki
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// Change log:
|
|
// June 20, 2001: ported by Nick Thurn to gcc 2.95.3. Kudos, Nick!!!
|
|
// May 10, 2002: ported by Rani Sharoni to VC7 (RTM - 9466)
|
|
// Oct 28, 2002: ported by Benjamin Kaufmann
|
|
// Feb 19, 2003: replaced pointer-Dummies with Type2Type-Parameters and added
|
|
// support for return type void.
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#endif
|