4.1

1 files changed, 0 insertions, 355 deletions

diff --git a/shared/loki/Visitor.h b/shared/loki/Visitor.h
deleted file mode 100644
index 85b8acd2..00000000
--- a/shared/loki/Visitor.h
+++ /dev/null
@@ -1,355 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-// 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-Wesley Longman make no representations about the
-//     suitability of this software for any purpose. It is provided "as is"
-//     without express or implied warranty.
-////////////////////////////////////////////////////////////////////////////////
-#ifndef LOKI_VISITOR_INC_
-#define LOKI_VISITOR_INC_
-
-// $Id: Visitor.h 751 2006-10-17 19:50:37Z syntheticpp $
-
-
-///  \defgroup VisitorGroup Visitor
-
-#include "Typelist.h"
-#include "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
-