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:
      typedef RET ReturnType;      
      typedef Tool ToolBase;      
      
      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::NullType, 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>
    {
      
      typedef typename BASE::ToolBase 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:
      typedef typename TOOL::ReturnType ReturnType;
      
      virtual ReturnType apply (TOOL&) = 0;
      
      
    protected:
      virtual ~Visitable () { };
      
      typedef typename TOOL::ToolBase 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