vtkDispatcher.h

Go to the documentation of this file.

/*=========================================================================

  Program:   Visualization Toolkit
  Module:    vtkDispatcher.h

  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
  All rights reserved.
  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notice for more information.

=========================================================================*/

// 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 vtkDispatcher_h
#define vtkDispatcher_h

#include "vtkDispatcher_Private.h" //needed for Functor,CastingPolicy,TypeInfo
#include <map> //Required for the storage of template params to runtime params

// class template FunctorDispatcher
template
  <
    class BaseLhs,
    typename ReturnType = void,
    template <class, class> class CastingPolicy = vtkDispatcherCommon::vtkCaster
  >
class vtkDispatcher
{
public:
  template <class SomeLhs, class Functor>
  void Add(Functor fun) { this->AddInternal<SomeLhs>(fun, 1); }

  template <class SomeLhs>
  bool Remove() { return DoRemove(typeid(SomeLhs)); }

  ReturnType Go(BaseLhs* lhs);

protected:
  typedef vtkDispatcherCommon::TypeInfo TypeInfo;
  typedef vtkDispatcherPrivate::Functor<ReturnType,BaseLhs> MappedType;

  void DoAddFunctor(TypeInfo lhs, MappedType fun);
  bool DoRemove(TypeInfo lhs);
  typedef std::map<TypeInfo, MappedType > MapType;
  MapType FunctorMap;
private:
  template <class SomeLhs, class Functor>
  void AddInternal(Functor const& fun, long);
  template <class SomeLhs, class Functor>
  void AddInternal(Functor* fun, int);
};

//We are making all these method non-inline to reduce compile time overhead
//----------------------------------------------------------------------------
template<class BaseLhs,typename ReturnType,
         template <class, class> class CastingPolicy>
template <class SomeLhs, class Functor>
void vtkDispatcher<BaseLhs,ReturnType,CastingPolicy>::AddInternal(const Functor& fun, long)
{
  typedef vtkDispatcherPrivate::FunctorDispatcherHelper<
      BaseLhs,
      SomeLhs,
      ReturnType,
      CastingPolicy<SomeLhs, BaseLhs>,
      Functor> Adapter;
  Adapter ada(fun);
  MappedType mt(ada);
  DoAddFunctor(typeid(SomeLhs),mt);
}


//----------------------------------------------------------------------------
template<class BaseLhs,typename ReturnType,
         template <class, class> class CastingPolicy>
template <class SomeLhs, class Functor>
void vtkDispatcher<BaseLhs,ReturnType,CastingPolicy>::AddInternal(Functor* fun, int)
{
  typedef vtkDispatcherPrivate::FunctorRefDispatcherHelper<
      BaseLhs,
      SomeLhs,
      ReturnType,
      CastingPolicy<SomeLhs, BaseLhs>,
      Functor> Adapter;
  Adapter ada(*fun);
  MappedType mt(ada);
  DoAddFunctor(typeid(SomeLhs),mt);
}

//----------------------------------------------------------------------------
template<class BaseLhs,typename ReturnType,
         template <class, class> class CastingPolicy>
void vtkDispatcher<BaseLhs,ReturnType,CastingPolicy>
::DoAddFunctor(TypeInfo lhs, MappedType fun)
{
  FunctorMap[TypeInfo(lhs)] = fun;
}

//----------------------------------------------------------------------------
template <class BaseLhs, typename ReturnType,
          template <class, class> class CastingPolicy>
bool vtkDispatcher<BaseLhs,ReturnType,CastingPolicy>
::DoRemove(TypeInfo lhs)
{
  return FunctorMap.erase(TypeInfo(lhs)) == 1;
}

//----------------------------------------------------------------------------
template <class BaseLhs,typename ReturnType,
          template <class, class> class CastingPolicy>
ReturnType vtkDispatcher<BaseLhs,ReturnType,CastingPolicy>
::Go(BaseLhs* lhs)
{
  typename MapType::key_type k(typeid(*lhs));
  typename MapType::iterator i = FunctorMap.find(k);
  if (i == FunctorMap.end())
  {
    //we return a default type, currently i don't want exceptions thrown
    return ReturnType();
  }
  return (i->second)(*lhs);
}

#endif // vtkDispatcher_h
// VTK-HeaderTest-Exclude: vtkDispatcher.h