lib/visitor.hpp

/*
  VISITOR.hpp  -  Generic Visitor library implementation
 
  Copyright (C)         Lumiera.org
    2008,               Hermann Vosseler <Ichthyostega@web.de>
 
  This program 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.
 
  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
 
  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

====================================================================
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 LUMIERA_VISITOR_H
#define LUMIERA_VISITOR_H

#include "lib/visitorpolicies.hpp"
#include "lib/visitordispatcher.hpp"

#include "lib/meta/typelist.hpp"


namespace lumiera
  {
  namespace visitor
    {
  
  
    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().enroll (typeref);
          }
        
      public:
        virtual Tag<ToolBase> 
        getTag ()
          {
            TOOLImpl* typeref = 0;
            return Tag<ToolBase>::get (typeref); 
          }
      };
    
    using typelist::Types;  // convienience for the user of "Applicable"
    
    
      
    template 
      < class TOOL = Tool<> 
      >
    class Visitable
      {
      protected:
        virtual ~Visitable () { };
        
        typedef typename TOOL::ToolBase ToolBase;
        typedef typename TOOL::ReturnType ReturnType;

        template <class TAR>
        static inline ReturnType
        dispatchOp (TAR& target, TOOL& tool)
          {
            return Dispatcher<TAR,ToolBase>::instance().forwardCall (target,tool);
          }
        
      public:
        virtual ReturnType apply (TOOL&) = 0;
      };
      

#define DEFINE_PROCESSABLE_BY(TOOL) \
        virtual ReturnType  apply (TOOL& tool) \
        { return dispatchOp (*this, tool); }
    
    
    
  } // namespace visitor

} // namespace lumiera
#endif

---