/home/hauberg/Dokumenter/Capture/humim-tracker-0.1/src/OpenTissue/OpenTissue/utility/dispatchers/dispatchers_dynamic_table_dispatcher.h

Go to the documentation of this file.

#ifndef OPENTISSUE_UTILITY_DISPATCHERS_DISPATCHERS_DYNAMIC_TABLE_DISPATCHER_H
#define OPENTISSUE_UTILITY_DISPATCHERS_DISPATCHERS_DYNAMIC_TABLE_DISPATCHER_H
//
// OpenTissue Template Library
// - A generic toolbox for physics-based modeling and simulation.
// Copyright (C) 2008 Department of Computer Science, University of Copenhagen.
//
// OTTL is licensed under zlib: http://opensource.org/licenses/zlib-license.php
//
#include <OpenTissue/configuration.h>

#include <OpenTissue/utility/dispatchers/dispatchers_unbound_dispatch_function.h>
#include <boost/multi_array.hpp>
#include <boost/shared_ptr.hpp>

namespace OpenTissue
{
  namespace utility
  {
    namespace dispatchers
    {

      template <
        class Base
          , bool Mirrored = false
          , typename R    = void
          , typename T3   = void
      >
      class DynamicTableDispatcher
      {
      private:

        class FunctorBase
        {
        public:

          virtual ~FunctorBase(){}

          virtual R operator()(Base& t1, Base& t2, T3& t3) const = 0;
        };

        template < class T1, class T2, bool Swap = false >
        class Functor
          : public FunctorBase
        {
        private:

          typedef R FuncType(T1&, T2&, T3&);

          FuncType* const m_func;

        public:

          Functor(FuncType* func)
            : m_func(func)
          {}

          R operator()(Base& t1, Base& t2, T3& t3) const
          {
            // Any good compiler is expected to optimize the branch away
            // as Swap is constant for the type
            if (Swap)
            {
              return m_func(static_cast<T1&>(t2), static_cast<T2&>(t1), t3);
            }
            else
            {
              return m_func(static_cast<T1&>(t1), static_cast<T2&>(t2), t3);
            }
          }
        };

      private:

        typedef boost::shared_ptr<FunctorBase>    FunctorPtr;
        typedef boost::multi_array<FunctorPtr, 2> FunctorTableType;

        FunctorTableType m_functor_table;          

      public:

        DynamicTableDispatcher()
          : m_functor_table( boost::extents[0][0])
        {}

        template < class T1, class T2 >
        void bind(R (*f)(T1&, T2&, T3&))
        {
          using std::max;

          boost::multi_array_types::index idx1 = T1::id();
          boost::multi_array_types::index idx2 = T2::id();

          // Resize the table if needed
          boost::multi_array_types::size_type max_idx = max(idx1, idx2);

          if (max_idx >= m_functor_table.shape()[0])
          {
            m_functor_table.resize(boost::extents[max_idx+1][max_idx+1]);
          }

          // Any good compiler should optimize the branch as Mirrored is
          // constant for the type
          if (Mirrored)
          {
            m_functor_table[idx2][idx1].reset(new Functor<T1,T2,true>(f));
          }

          m_functor_table[idx1][idx2].reset(new Functor<T1,T2,false>(f));
        }

        R operator()(Base& t1, Base& t2, T3& t3)
        {
          using std::max;

          boost::multi_array_types::index idx1 = t1.class_id();
          boost::multi_array_types::index idx2 = t2.class_id();

          boost::multi_array_types::size_type max_idx = max(idx1, idx2);

          // Range check
          if (max_idx >= m_functor_table.shape()[0]) 
            throw UnboundDispatchFunction();

          FunctorPtr f = m_functor_table[idx1][idx2];

          // Sanity check the pointer
          if (f.get()==0) 
            throw UnboundDispatchFunction();

          return f->operator()(t1, t2, t3);
        }
      };


      /****************************************************************************************************/

      template < class Base, bool Mirrored, typename R >
      class DynamicTableDispatcher<Base, Mirrored, R, void>
      {
      private:

        class FunctorBase
        {
        public:

          virtual ~FunctorBase(){}

          virtual R operator()(Base& t1, Base& t2) const = 0;

        };

        template < class T1, class T2, bool Swap = false >
        class Functor
          : public FunctorBase
        {
        private:

          typedef R FuncType(T1&, T2&);

          FuncType* const m_func;

        public:

          Functor(FuncType* func)
            : m_func(func)
          {}

          R operator()(Base& t1, Base& t2) const
          {
            // Any good compiler is expected to optimize the branch away
            // as Swap is constant for the type
            if (Swap)
            {
              return m_func(static_cast<T1&>(t2), static_cast<T2&>(t1));
            }
            else
            {
              return m_func(static_cast<T1&>(t1), static_cast<T2&>(t2));
            }
          }
        };

      private:

        typedef boost::shared_ptr<FunctorBase>    FunctorPtr;
        typedef boost::multi_array<FunctorPtr, 2> FunctorTableType;

        FunctorTableType m_functor_table;

      public:

        DynamicTableDispatcher()
          : m_functor_table(boost::extents[0][0])
        {}

        template < class T1, class T2 >
        void bind(R (*f)(T1&, T2&))
        {
          using std::max;

          boost::multi_array_types::index idx1 = T1::id();
          boost::multi_array_types::index idx2 = T2::id();

          // Resize the table if needed
          boost::multi_array_types::size_type max_idx = max(idx1, idx2);

          if (max_idx >= m_functor_table.shape()[0])
          {
            m_functor_table.resize(boost::extents[max_idx+1][max_idx+1]);
          }

          // Any good compiler should optimize the branch as Mirrored is
          // constant for the type
          if (Mirrored)
          {
            m_functor_table[idx2][idx1].reset(new Functor<T1,T2,true>(f));
          } 
          m_functor_table[idx1][idx2].reset(new Functor<T1,T2,false>(f));
        }

        R operator()(Base& t1, Base& t2)
        {
          using std::max;

          boost::multi_array_types::index idx1 = t1.class_id();
          boost::multi_array_types::index idx2 = t2.class_id();

          boost::multi_array_types::size_type max_idx = max(idx1, idx2);

          // Range check
          if (max_idx >= m_functor_table.shape()[0]) 
            throw UnboundDispatchFunction();

          FunctorPtr f = m_functor_table[idx1][idx2];

          // Sanity check the pointer
          if (f.get()==0) 
            throw UnboundDispatchFunction();

          return f->operator()(t1, t2);
        }
      };

    } // namespace dispatchers
  } // namespace utility
} // namespace OpenTissue

// OPENTISSUE_UTILITY_DISPATCHERS_DISPATCHERS_DYNAMIC_TABLE_DISPATCHER_H
#endif