AttachedVirtualFunction.h

Go to the documentation of this file.

/*!********************************************************************
 
Audacity: A Digital Audio Editor
 
@file AttachedVirtualFunction.h
@brief Utility for non-intrusive definition of a new method on a base class
 
Paul Licameli
 
**********************************************************************/
 
#ifndef __AUDACITY_ATTACHED_VIRTUAL_FUNCTION__
#define __AUDACITY_ATTACHED_VIRTUAL_FUNCTION__
 
 
#include <functional>
#include <mutex>
#include <type_traits>
#include <utility>
#include "InconsistencyException.h"
 
 
template< typename Tag, typename Return, typename This, typename... Arguments >
class AttachedVirtualFunction
{
public:
 
   using Object = This;
   using Function = std::function< Return( Object&, Arguments... ) >;
 
   static Function Implementation();
 
 
   AttachedVirtualFunction();
 
 
   template<
      typename Subclass, typename Overridden = AttachedVirtualFunction >
   struct Override : Overridden
   {
      using Object = Subclass;
      using Function = std::function< Return( Object&, Arguments... ) >;
 
      // Check that inheritance is correct
      static_assert(
         std::is_base_of_v< typename Overridden::Object, Object >,
         "overridden class must be a base of the overriding class"
      );
 
      static Function Implementation();
      static Return Callthrough(
         typename Overridden::Object &object, Arguments &&...arguments )
      {
         return Overridden::Implementation()(
            object, std::forward< Arguments >( arguments )... );
      }
 
      Override()
      {
         static std::once_flag flag;
         std::call_once( flag, []{
            // Register in the table an adaptor thunk that downcasts the object
            auto implementation = Implementation();
            Register< Subclass >( [=]( This &obj, Arguments ...arguments ){
               return implementation(
                  static_cast< Subclass& >( obj ),
                  std::forward< Arguments >( arguments )... );
            });
         });
      }
   };
 
   static Return Call(
      This &obj, 
      Arguments ...arguments 
   )
   {
      try {
         // Note that the constructors of this class and overrides cause
         // the registry to be topologically sorted, with functions for
         // less-derived classes earlier in the table; so take the last
         // one that matches the object.  (The object might not be of the exact
         // class corresponding to any of the overrides, which is why this
         // solution involves calling the predicates generated in Register,
         // and wouldn't work just with hashing on std::type_index; but perhaps
         // such a cache could be memo-ized)
         auto &registry = GetRegistry();
         auto iter = registry.rbegin(), end = registry.rend();
         for ( ; iter != end; ++iter ) {
            auto &entry = *iter;
            if ( entry.predicate( &obj ) )
               // This might throw std::bad_function_call on a null function
               return entry.function(
                  obj, std::forward< Arguments >( arguments )... );
         }
         // If not found, also throw
         throw std::bad_function_call{};
      }
      catch ( const std::bad_function_call& ) {
         // No matching case found with a non-null function.
         // Translate the exception
         THROW_INCONSISTENCY_EXCEPTION;
      }
   }
 
private:
   template< typename Subclass >
   static void Register( const Function &function )
   {
      // Push back a dynamic type test and corresponding function body
      GetRegistry().push_back({
         []( This *b ){ return dynamic_cast< Subclass * >( b ) != nullptr; },
         function
      });
   }
 
   using Predicate = std::function< bool( This* ) >;
 
   struct Entry
   {
      Predicate predicate;
      Function function;
   };
 
   using Registry = std::vector< Entry >;
   static Registry &GetRegistry();
};
 
#define DECLARE_EXPORTED_ATTACHED_VIRTUAL(DECLSPEC, Name)      \
   template<> DECLSPEC Name::AttachedVirtualFunction();        \
   template<> auto DECLSPEC Name::GetRegistry() -> Registry &; \
   template<> auto DECLSPEC Name::Implementation() -> Function
 
#define DEFINE_ATTACHED_VIRTUAL(Name)                          \
   template<> Name::AttachedVirtualFunction()                  \
   {                                                           \
      static std::once_flag flag;                              \
      std::call_once( flag, []{ Register<Object>( Implementation() ); } ); \
   }                                                           \
   template<> auto Name::GetRegistry() -> Registry &           \
   {                                                           \
      static Registry registry;                                \
      return registry;                                         \
   }                                                           \
   static Name register ## Name ;                              \
   template<> auto Name::Implementation() -> Function
 
#define DEFINE_ATTACHED_VIRTUAL_OVERRIDE(Name)                 \
   static Name register ## Name ;                              \
   template<> template<> auto Name::Implementation() -> Function \
 
#endif