d2ca522cca
git-svn-id: svn://svn.code.sf.net/p/loki-lib/code/trunk@1115 7ec92016-0320-0410-acc4-a06ded1c099a
367 lines
11 KiB
C++
367 lines
11 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.
|
|
// Code covered by the MIT License
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
// of this software and associated documentation files (the "Software"), to deal
|
|
// in the Software without restriction, including without limitation the rights
|
|
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
// copies of the Software, and to permit persons to whom the Software is
|
|
// furnished to do so, subject to the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be included in
|
|
// all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
// SOFTWARE.
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
#ifndef LOKI_VISITOR_INC_
|
|
#define LOKI_VISITOR_INC_
|
|
|
|
// $Id$
|
|
|
|
|
|
/// \defgroup VisitorGroup Visitor
|
|
|
|
#include <loki/Typelist.h>
|
|
#include <loki/HierarchyGenerators.h>
|
|
|
|
namespace Loki
|
|
{
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// \class BaseVisitor
|
|
///
|
|
/// \ingroup VisitorGroup
|
|
/// The base class of any Acyclic Visitor
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
class BaseVisitor
|
|
{
|
|
public:
|
|
virtual ~BaseVisitor() {}
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// \class Visitor
|
|
///
|
|
/// \ingroup VisitorGroup
|
|
/// The building block of Acyclic Visitor
|
|
///
|
|
/// \par Usage
|
|
///
|
|
/// Defining the visitable class:
|
|
///
|
|
/// \code
|
|
/// class RasterBitmap : public BaseVisitable<>
|
|
/// {
|
|
/// public:
|
|
/// LOKI_DEFINE_VISITABLE()
|
|
/// };
|
|
/// \endcode
|
|
///
|
|
/// Way 1 to define a visitor:
|
|
/// \code
|
|
/// class SomeVisitor :
|
|
/// public BaseVisitor // required
|
|
/// public Visitor<RasterBitmap>,
|
|
/// public Visitor<Paragraph>
|
|
/// {
|
|
/// public:
|
|
/// void Visit(RasterBitmap&); // visit a RasterBitmap
|
|
/// void Visit(Paragraph &); // visit a Paragraph
|
|
/// };
|
|
/// \endcode
|
|
///
|
|
/// Way 2 to define the visitor:
|
|
/// \code
|
|
/// class SomeVisitor :
|
|
/// public BaseVisitor // required
|
|
/// public Visitor<LOKI_TYPELIST_2(RasterBitmap, Paragraph)>
|
|
/// {
|
|
/// public:
|
|
/// void Visit(RasterBitmap&); // visit a RasterBitmap
|
|
/// void Visit(Paragraph &); // visit a Paragraph
|
|
/// };
|
|
/// \endcode
|
|
///
|
|
/// Way 3 to define the visitor:
|
|
/// \code
|
|
/// class SomeVisitor :
|
|
/// public BaseVisitor // required
|
|
/// public Visitor<Seq<RasterBitmap, Paragraph>::Type>
|
|
/// {
|
|
/// public:
|
|
/// void Visit(RasterBitmap&); // visit a RasterBitmap
|
|
/// void Visit(Paragraph &); // visit a Paragraph
|
|
/// };
|
|
/// \endcode
|
|
///
|
|
/// \par Using const visit functions:
|
|
///
|
|
/// Defining the visitable class (true for const):
|
|
///
|
|
/// \code
|
|
/// class RasterBitmap : public BaseVisitable<void, DefaultCatchAll, true>
|
|
/// {
|
|
/// public:
|
|
/// LOKI_DEFINE_CONST_VISITABLE()
|
|
/// };
|
|
/// \endcode
|
|
///
|
|
/// Defining the visitor which only calls const member functions:
|
|
/// \code
|
|
/// class SomeVisitor :
|
|
/// public BaseVisitor // required
|
|
/// public Visitor<RasterBitmap, void, true>,
|
|
/// {
|
|
/// public:
|
|
/// void Visit(const RasterBitmap&); // visit a RasterBitmap by a const member function
|
|
/// };
|
|
/// \endcode
|
|
///
|
|
/// \par Example:
|
|
///
|
|
/// test/Visitor/main.cpp
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
template <class T, typename R = void, bool ConstVisit = false>
|
|
class Visitor;
|
|
|
|
template <class T, typename R>
|
|
class Visitor<T, R, false>
|
|
{
|
|
public:
|
|
typedef R ReturnType;
|
|
typedef T ParamType;
|
|
virtual ~Visitor() {}
|
|
virtual ReturnType Visit(ParamType&) = 0;
|
|
};
|
|
|
|
template <class T, typename R>
|
|
class Visitor<T, R, true>
|
|
{
|
|
public:
|
|
typedef R ReturnType;
|
|
typedef const T ParamType;
|
|
virtual ~Visitor() {}
|
|
virtual ReturnType Visit(ParamType&) = 0;
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// class template Visitor (specialization)
|
|
// This specialization is not present in the book. It makes it easier to define
|
|
// Visitors for multiple types in a shot by using a typelist. Example:
|
|
//
|
|
// class SomeVisitor :
|
|
// public BaseVisitor // required
|
|
// public Visitor<LOKI_TYPELIST_2(RasterBitmap, Paragraph)>
|
|
// {
|
|
// public:
|
|
// void Visit(RasterBitmap&); // visit a RasterBitmap
|
|
// void Visit(Paragraph &); // visit a Paragraph
|
|
// };
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
template <class Head, class Tail, typename R>
|
|
class Visitor<Typelist<Head, Tail>, R, false>
|
|
: public Visitor<Head, R, false>, public Visitor<Tail, R, false>
|
|
{
|
|
public:
|
|
typedef R ReturnType;
|
|
// using Visitor<Head, R>::Visit;
|
|
// using Visitor<Tail, R>::Visit;
|
|
};
|
|
|
|
template <class Head, typename R>
|
|
class Visitor<Typelist<Head, NullType>, R, false> : public Visitor<Head, R, false>
|
|
{
|
|
public:
|
|
typedef R ReturnType;
|
|
using Visitor<Head, R, false>::Visit;
|
|
};
|
|
|
|
template <class Head, class Tail, typename R>
|
|
class Visitor<Typelist<Head, Tail>, R, true>
|
|
: public Visitor<Head, R, true>, public Visitor<Tail, R, true>
|
|
{
|
|
public:
|
|
typedef R ReturnType;
|
|
// using Visitor<Head, R>::Visit;
|
|
// using Visitor<Tail, R>::Visit;
|
|
};
|
|
|
|
template <class Head, typename R>
|
|
class Visitor<Typelist<Head, NullType>, R, true> : public Visitor<Head, R, true>
|
|
{
|
|
public:
|
|
typedef R ReturnType;
|
|
using Visitor<Head, R, true>::Visit;
|
|
};
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// class template BaseVisitorImpl
|
|
// Implements non-strict visitation (you can implement only part of the Visit
|
|
// functions)
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
template <class TList, typename R = void> class BaseVisitorImpl;
|
|
|
|
template <class Head, class Tail, typename R>
|
|
class BaseVisitorImpl<Typelist<Head, Tail>, R>
|
|
: public Visitor<Head, R>
|
|
, public BaseVisitorImpl<Tail, R>
|
|
{
|
|
public:
|
|
// using BaseVisitorImpl<Tail, R>::Visit;
|
|
|
|
virtual R Visit(Head&)
|
|
{ return R(); }
|
|
};
|
|
|
|
template <class Head, typename R>
|
|
class BaseVisitorImpl<Typelist<Head, NullType>, R>
|
|
: public Visitor<Head, R>
|
|
{
|
|
public:
|
|
virtual R Visit(Head&)
|
|
{ return R(); }
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// class template BaseVisitable
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
template <typename R, typename Visited>
|
|
struct DefaultCatchAll
|
|
{
|
|
static R OnUnknownVisitor(Visited&, BaseVisitor&)
|
|
{ return R(); }
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// class template BaseVisitable
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
template
|
|
<
|
|
typename R = void,
|
|
template <typename, class> class CatchAll = DefaultCatchAll,
|
|
bool ConstVisitable = false
|
|
>
|
|
class BaseVisitable;
|
|
|
|
template<typename R,template <typename, class> class CatchAll>
|
|
class BaseVisitable<R, CatchAll, false>
|
|
{
|
|
public:
|
|
typedef R ReturnType;
|
|
virtual ~BaseVisitable() {}
|
|
virtual ReturnType Accept(BaseVisitor&) = 0;
|
|
|
|
protected: // give access only to the hierarchy
|
|
template <class T>
|
|
static ReturnType AcceptImpl(T& visited, BaseVisitor& guest)
|
|
{
|
|
// Apply the Acyclic Visitor
|
|
if (Visitor<T,R>* p = dynamic_cast<Visitor<T,R>*>(&guest))
|
|
{
|
|
return p->Visit(visited);
|
|
}
|
|
return CatchAll<R, T>::OnUnknownVisitor(visited, guest);
|
|
}
|
|
};
|
|
|
|
template<typename R,template <typename, class> class CatchAll>
|
|
class BaseVisitable<R, CatchAll, true>
|
|
{
|
|
public:
|
|
typedef R ReturnType;
|
|
virtual ~BaseVisitable() {}
|
|
virtual ReturnType Accept(BaseVisitor&) const = 0;
|
|
|
|
protected: // give access only to the hierarchy
|
|
template <class T>
|
|
static ReturnType AcceptImpl(const T& visited, BaseVisitor& guest)
|
|
{
|
|
// Apply the Acyclic Visitor
|
|
if (Visitor<T,R,true>* p = dynamic_cast<Visitor<T,R,true>*>(&guest))
|
|
{
|
|
return p->Visit(visited);
|
|
}
|
|
return CatchAll<R, T>::OnUnknownVisitor(const_cast<T&>(visited), guest);
|
|
}
|
|
};
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// \def LOKI_DEFINE_VISITABLE()
|
|
/// \ingroup VisitorGroup
|
|
/// Put it in every class that you want to make visitable
|
|
/// (in addition to deriving it from BaseVisitable<R>)
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#define LOKI_DEFINE_VISITABLE() \
|
|
virtual ReturnType Accept(::Loki::BaseVisitor& guest) \
|
|
{ return AcceptImpl(*this, guest); }
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// \def LOKI_DEFINE_CONST_VISITABLE()
|
|
/// \ingroup VisitorGroup
|
|
/// Put it in every class that you want to make visitable by const member
|
|
/// functions (in addition to deriving it from BaseVisitable<R>)
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#define LOKI_DEFINE_CONST_VISITABLE() \
|
|
virtual ReturnType Accept(::Loki::BaseVisitor& guest) const \
|
|
{ return AcceptImpl(*this, guest); }
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// \class CyclicVisitor
|
|
///
|
|
/// \ingroup VisitorGroup
|
|
/// Put it in every class that you want to make visitable (in addition to
|
|
/// deriving it from BaseVisitable<R>
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
template <typename R, class TList>
|
|
class CyclicVisitor : public Visitor<TList, R>
|
|
{
|
|
public:
|
|
typedef R ReturnType;
|
|
// using Visitor<TList, R>::Visit;
|
|
|
|
template <class Visited>
|
|
ReturnType GenericVisit(Visited& host)
|
|
{
|
|
Visitor<Visited, ReturnType>& subObj = *this;
|
|
return subObj.Visit(host);
|
|
}
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// \def LOKI_DEFINE_CYCLIC_VISITABLE(SomeVisitor)
|
|
/// \ingroup VisitorGroup
|
|
/// Put it in every class that you want to make visitable by a cyclic visitor
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#define LOKI_DEFINE_CYCLIC_VISITABLE(SomeVisitor) \
|
|
virtual SomeVisitor::ReturnType Accept(SomeVisitor& guest) \
|
|
{ return guest.GenericVisit(*this); }
|
|
|
|
} // namespace Loki
|
|
|
|
|
|
|
|
#endif // end file guardian
|
|
|