vtable.h

Go to the documentation of this file.

 
#ifndef VTABLE_H
#define VTABLE_H
 
#include <vector>
#include <cstddef>
 
#include <argos3/core/utility/logging/argos_log.h>
 
namespace argos {
 
   template <typename BASE>
   struct STagCounter {
      static size_t Count;
   };
   template <typename BASE>
   size_t STagCounter<BASE>::Count(0);
 
   template <typename DERIVED, typename BASE>
   struct STagHolder {
      static size_t Tag;
   };
 
   template <typename DERIVED, typename BASE>
   size_t GetTag() {
      size_t& unTag = STagHolder<const DERIVED, const BASE>::Tag;
      if(unTag == 0) {
         /* First call of this function, generate non-zero tag */
         ++STagCounter<const BASE>::Count;
         unTag = STagCounter<const BASE>::Count;
      }
      return unTag;
   }
 
   template <typename DERIVED, typename BASE>
   size_t STagHolder<DERIVED, BASE>::Tag = GetTag<DERIVED, BASE>();
 
   template <typename BASE>
   struct EnableVTableFor {
      template <typename DERIVED>
      size_t GetTagHelper(const DERIVED*) const {
         return GetTag<DERIVED, BASE>();
      }
   };
 
#define ENABLE_VTABLE()                         \
   virtual size_t GetTag() {                    \
      return GetTagHelper(this);                \
   }
 
   template <typename CONTEXT, typename BASE, typename FUNCTION>
   class CVTable {
   public:
      template <typename DERIVED>
      void Add(FUNCTION t_function) {
         /* Find the slot */
         size_t unIndex = GetTag<DERIVED, BASE>();
         /* Does the table have a slot for this index? */
         if(unIndex >= m_vecVTable.size()) {
            /* No, new slots must be created
             * Fill the slots with the default function that handles BASE
             * or NULL if such function does not exist
             */
            /* Get the tag associated to the base class */
            const size_t unBaseTag = GetTag<BASE, BASE>();
            FUNCTION tDefaultFunction = 0;
            if(unBaseTag < m_vecVTable.size()) {
               tDefaultFunction = m_vecVTable[unBaseTag];
            }
            /* Create new slots up to index+1 and fill them with tDefaultFunction */
            m_vecVTable.resize(unIndex+1, tDefaultFunction);
         }
         m_vecVTable[unIndex] = t_function;
      }
 
      FUNCTION operator[](size_t un_index) const {
         if(un_index >= m_vecVTable.size()) {
            un_index = GetTag<BASE, BASE>();
         }
         return m_vecVTable[un_index];
      }
 
      inline size_t Size() const {
         return m_vecVTable.size();
      }
 
   private:
      std::vector<FUNCTION> m_vecVTable;
 
   };
 
   template <typename CONTEXT, typename BASE, typename FUNCTION>
   CVTable<CONTEXT, BASE, FUNCTION>& GetVTable() {
      static CVTable<CONTEXT, BASE, FUNCTION> cVTable;
      return cVTable;
   }
   
#define INIT_VTABLE_FOR(BASE)                   \
   struct SVTableInitializerFor ## BASE {       \
      SVTableInitializerFor ## BASE() {         \
         GetTag<BASE, BASE>();                  \
      }                                         \
   } sVTableInitializerFor ## BASE;
 
}
 
#endif