visitor.hpp

Go to the documentation of this file.

/*
  VISITOR.hpp  -  Generic Visitor library implementation
 
   Copyright (C)
     2008,            Hermann Vosseler <Ichthyostega@web.de>
 
 **Lumiera** is free software; you can redistribute it and/or modify it
 under the terms of the GNU General Public License as published by the
 Free Software Foundation; either version 2 of the License, or (at your
 option) any later version. See the file COPYING for further details.
 
====================================================================
This code is heavily inspired by
 The Loki Library (loki-lib/trunk/include/loki/Visitor.h)
    Copyright (c) 2001 by Andrei Alexandrescu
    This Loki code accompanies the book:
    Alexandrescu, Andrei. "Modern C++ Design: Generic Programming
        and Design Patterns Applied".
        Copyright (c) 2001. Addison-Wesley. ISBN 0201704315
 
Credits for many further implementation ideas go to
 Cooperative Visitor: A Template Technique for Visitor Creation
    by Anand Shankar Krishnamoorthi   (July 2007)
    http://www.artima.com/cppsource/cooperative_visitor.html
 
*/
 
 
#ifndef LIB_VISITOR_H
#define LIB_VISITOR_H
 
#include "lib/visitor-policies.hpp"
#include "lib/visitor-dispatcher.hpp"
 
#include "lib/meta/typelist.hpp"
 
 
namespace lib {
namespace visitor {
  
  namespace typelist = lib::meta;
  
  
  template
    < typename RET = void
    , template <class> class ERR = UseDefault
    >
  class Tool : public ERR<RET>
    {
    public:
      using ReturnType = RET;      
      using ToolBase  = Tool;     
      
      virtual ~Tool ()  { };    
      
      virtual Tag<ToolBase> getTag() = 0;
    };
  
  
  
  
  template
    < class TOOLImpl,      // concrete tool implementation type
      class TYPES,        // List of applicable Types goes here...
      class BASE=Tool<>  // "visiting tool" base class
    >
  class Applicable;
  
  template           // recursion end: inherit from BASE
    < class TOOLImpl,
      class BASE
    >
  class Applicable<TOOLImpl, typelist::Nil, BASE>
    : public BASE
  { }
  ;
  
  template
    < class TOOLImpl,
      class TAR, class TYPES,
      class BASE
    >
  class Applicable<TOOLImpl, typelist::Node<TAR, TYPES>, BASE>
    : public Applicable<TOOLImpl, TYPES, BASE>
    {
      
      using ToolBase = BASE::ToolBase;
      
    protected:
      virtual ~Applicable () {}
      Applicable ()
        {
          TOOLImpl* typeref = 0;
          Dispatcher<TAR,ToolBase>::instance().enrol (typeref);
        }
      
    public:
      virtual Tag<ToolBase>
      getTag ()
        {
          TOOLImpl* typeref = 0;
          return Tag<ToolBase>::get (typeref);
        }
    };
  
  using typelist::Types;  // convenience for the user of "Applicable"
  
  
  
  template
    < class TOOL = Tool<>
    >
  class Visitable
    {
    public:
      using ReturnType = TOOL::ReturnType;
      
      virtual ReturnType apply (TOOL&) = 0;
      
      
    protected:
      virtual ~Visitable () { };
      
      using ToolBase = TOOL::ToolBase;
      
      template <class TAR>
      static inline ReturnType
      dispatchOp (TAR& target, TOOL& tool)
        {
          return Dispatcher<TAR,ToolBase>::instance().forwardCall (target,tool);
        }
    };
    
 
#define DEFINE_PROCESSABLE_BY(TOOL) \
        virtual ReturnType  apply (TOOL& tool) \
        { return dispatchOp (*this, tool); }
  
  
  
}} // namespace lib::visitor
#endif