vtkDoubleDispatcher.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkDoubleDispatcher.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 vtkDoubleDispatcher_h
#define vtkDoubleDispatcher_h
 
#ifndef __VTK_WRAP__
 
#include "vtkDeprecation.h"        // for VTK_DEPRECATED_IN_9_0_0
#include "vtkDispatcher_Private.h" //needed for Functor,CastingPolicy,TypeInfo
#include <map>                     //Required for the storage of template params to runtime params
 
template <class BaseLhs, class BaseRhs = BaseLhs, typename ReturnType = void,
  template <class, class> class CastingPolicy = vtkDispatcherCommon::vtkCaster>
VTK_DEPRECATED_IN_9_0_0("Use vtkArrayDispatch")
class vtkDoubleDispatcher
{
public:
  template <class SomeLhs, class SomeRhs, class Functor>
  void Add(Functor fun)
  {
    VTK_LEGACY_BODY(vtkDoubleDispatcher, "VTK 9.0");
    this->AddInternal<SomeLhs, SomeRhs>(fun, 1);
  }
 
  template <class SomeLhs, class SomeRhs>
  bool Remove()
  {
    return DoRemove(typeid(SomeLhs), typeid(SomeRhs));
  }
 
  ReturnType Go(BaseLhs* lhs, BaseRhs* rhs);
 
protected:
  typedef vtkDispatcherCommon::TypeInfo TypeInfo;
  typedef vtkDoubleDispatcherPrivate::Functor<ReturnType, BaseLhs, BaseRhs> MappedType;
 
  void DoAddFunctor(TypeInfo lhs, TypeInfo rhs, MappedType fun);
  bool DoRemove(TypeInfo lhs, TypeInfo rhs);
 
  typedef std::pair<TypeInfo, TypeInfo> KeyType;
  typedef std::map<KeyType, MappedType> MapType;
  MapType FunctorMap;
 
private:
  template <class SomeLhs, class SomeRhs, class Functor>
  void AddInternal(const Functor& fun, long);
  template <class SomeLhs, class SomeRhs, class Functor>
  void AddInternal(Functor* fun, int);
};
 
// We are making all these method non-inline to reduce compile time overhead
//----------------------------------------------------------------------------
template <class BaseLhs, class BaseRhs, typename ReturnType,
  template <class, class> class CastingPolicy>
template <class SomeLhs, class SomeRhs, class Functor>
VTK_DEPRECATED_IN_9_0_0("Use vtkArrayDispatch")
void vtkDoubleDispatcher<BaseLhs, BaseRhs, ReturnType, CastingPolicy>::AddInternal(
  const Functor& fun, long)
{
  typedef vtkDoubleDispatcherPrivate::FunctorDoubleDispatcherHelper<BaseLhs, BaseRhs, SomeLhs,
    SomeRhs, ReturnType, CastingPolicy<SomeLhs, BaseLhs>, CastingPolicy<SomeRhs, BaseRhs>, Functor>
    Adapter;
  Adapter ada(fun);
  MappedType mt(ada);
  DoAddFunctor(typeid(SomeLhs), typeid(SomeRhs), mt);
}
 
//----------------------------------------------------------------------------
template <class BaseLhs, class BaseRhs, typename ReturnType,
  template <class, class> class CastingPolicy>
template <class SomeLhs, class SomeRhs, class Functor>
VTK_DEPRECATED_IN_9_0_0("Use vtkArrayDispatch")
void vtkDoubleDispatcher<BaseLhs, BaseRhs, ReturnType, CastingPolicy>::AddInternal(
  Functor* fun, int)
{
  typedef vtkDoubleDispatcherPrivate::FunctorRefDispatcherHelper<BaseLhs, BaseRhs, SomeLhs, SomeRhs,
    ReturnType, CastingPolicy<SomeLhs, BaseLhs>, CastingPolicy<SomeRhs, BaseRhs>, Functor>
    Adapter;
  Adapter ada(*fun);
  MappedType mt(ada);
  DoAddFunctor(typeid(SomeLhs), typeid(SomeRhs), mt);
}
 
//----------------------------------------------------------------------------
template <class BaseLhs, class BaseRhs, typename ReturnType,
  template <class, class> class CastingPolicy>
VTK_DEPRECATED_IN_9_0_0("Use vtkArrayDispatch")
void vtkDoubleDispatcher<BaseLhs, BaseRhs, ReturnType, CastingPolicy>::DoAddFunctor(
  TypeInfo lhs, TypeInfo rhs, MappedType fun)
{
  FunctorMap[KeyType(lhs, rhs)] = fun;
}
 
//----------------------------------------------------------------------------
template <class BaseLhs, class BaseRhs, typename ReturnType,
  template <class, class> class CastingPolicy>
VTK_DEPRECATED_IN_9_0_0("Use vtkArrayDispatch")
bool vtkDoubleDispatcher<BaseLhs, BaseRhs, ReturnType, CastingPolicy>::DoRemove(
  TypeInfo lhs, TypeInfo rhs)
{
  return FunctorMap.erase(KeyType(lhs, rhs)) == 1;
}
 
//----------------------------------------------------------------------------
template <class BaseLhs, class BaseRhs, typename ReturnType,
  template <class, class> class CastingPolicy>
VTK_DEPRECATED_IN_9_0_0("Use vtkArrayDispatch")
ReturnType vtkDoubleDispatcher<BaseLhs, BaseRhs, ReturnType, CastingPolicy>::Go(
  BaseLhs* lhs, BaseRhs* rhs)
{
  typename MapType::key_type k(typeid(*lhs), typeid(*rhs));
  typename MapType::iterator i = FunctorMap.find(k);
  if (i == FunctorMap.end())
  {
    // we don't want to throw exceptions so we have two options.
    // we can return the default, or make a lightweight struct for return value
    return ReturnType();
  }
  return (i->second)(*lhs, *rhs);
}
 
#endif // __VTK_WRAP__
#endif // vtkDoubleDispatcher_h
// VTK-HeaderTest-Exclude: vtkDoubleDispatcher.h