TypeSwitch.h

Go to the documentation of this file.

/*!********************************************************************
 
  Audacity: A Digital Audio Editor
 
  @file TypeSwitch.h
  @brief Dispatch to one of a set of functions by the run-time type of an object
 
  Paul Licameli
 
**********************************************************************/
#ifndef __AUDACITY_TYPE_SWITCH__
#define __AUDACITY_TYPE_SWITCH__
 
#include "Callable.h"
#include "Tuple.h"
#include "TypeList.h"
#include <cassert>
 
namespace TypeSwitch {
using namespace TypeList;
 
namespace detail {
 
template<typename... Functions> using FunctionTupleType =
   std::tuple<const Functions &...>;
template<typename Functions> using FunctionTuple =
   Apply_t<FunctionTupleType, Functions>;
 
 
template<typename R, typename ArgumentTypes, typename Funs, typename... Args>
struct Executor {
   static_assert(!Null_v<ArgumentTypes>);
   using ArgumentType = Head_t<ArgumentTypes>;
 
   struct NoOp {
      struct type {
         using Functions = FunctionTuple<Nil>;
 
         enum : unsigned { SetUsed = 0 };
         R operator ()(ArgumentType &, const Functions &, Args&&...) const {
            if constexpr (std::is_void_v<R>)
               return;
            else
               return R{};
         }
      };
   };
 
   template<typename Fs, typename Wrapped> struct Combine {
      using Functions = FunctionTuple<Fs>;
      struct Transparent {
         struct type {
            using Next = typename Wrapped::type;
 
            enum : unsigned { SetUsed = Next::SetUsed << 1 };
 
            R operator ()(
               ArgumentType &object, const Functions &functions, Args&&... args)
            const {
               return Next{}(object, Tuple::ForwardNext(functions),
                  std::forward<Args>(args)...);
            }
         };
      };
 
      template<typename BaseClass, typename NextBase> struct CombineOp {
         static_assert(
            std::is_const_v<BaseClass> == std::is_const_v<ArgumentType>);
         using Compatible = std::is_base_of<BaseClass, ArgumentType>;
 
         struct Opaque {
            enum : unsigned { SetUsed = 1u };
 
            R operator ()(
               BaseClass &object, const Functions &functions, Args&&... args)
            const {
               return std::get<0>(functions)(
                  object, std::forward<Args>(args)...);
            }
         };
 
         struct Wrapper {
            using Next = typename Wrapped::type;
            enum : unsigned { SetUsed = (Next::SetUsed << 1) | 1u };
 
            R operator ()(
               BaseClass &object, const Functions &functions, Args&&... args)
            const {
               // The first function in the tuple is curried!
               // Its first argument is the call-through and its second
               // is the object
               const auto next = [&](){ return
                  Next{}(object, Tuple::ForwardNext(functions),
                     std::forward<Args>(args)...); };
               return std::get<0>(functions)(next)(
                  object, std::forward<Args>(args)...);
            }
         };
 
         using F = Head_t<Fs>;
 
         // whether Function looks like a generic callable
         struct Dummy { R operator ()() const {
            if constexpr(std::is_void_v<R>) return; else return R{};
         } };
         using curried = std::is_invocable<F, Dummy&&>;
 
         // Case 1: Compatible, and invocable on the next function, giving
         // another function, that accepts BaseClass:
         struct Case1_;
         using Case1 = std::conjunction<Compatible, curried, Case1_>;
         struct Case1_ {
            static constexpr bool value = std::is_invocable_v<
               std::invoke_result_t<F, Dummy &&>, BaseClass&, Args&&...>;
            using type = Wrapper;
         };
 
         // Case 2: Invocable directly on the object
         struct Case2 : std::conjunction<
            Compatible, std::negation<curried>,
            std::is_invocable<F, BaseClass&, Args&&...>
         > {
            using type = Opaque;
         };
         struct Default : std::true_type {
            using type = typename NextBase::type;
         };
         using type = typename std::disjunction<Case1, Case2, Default>::type;
      };
      using type =
         typename LeftFold_t<CombineOp, ArgumentTypes, Transparent>::type;
   };
 
   using type = typename RightFoldList_t<Combine, Funs, NoOp>::type;
};
 
 
template<
   typename R, typename ArgumentTypes, typename Functions, typename... Args>
using Executor_t =
   typename Executor<R, ArgumentTypes, Functions, Args...>::type;
 
// Executors for more derived classes are later in the given type list
template<typename R, typename Exec, typename ObjectTypes>
struct Invoker {
private:
   struct Base {
      template<typename Object, typename Functions, typename... Args>
      R operator ()(Object &object, const Functions &functions, Args&&...)
      const {
         // This should never be reached at run-time, because an Executor
         // generated for (const) Object should have been the catch-all.
         assert(false);
         if constexpr (std::is_void_v<R>)
            return;
         else
            return R{};
      }
   };
   template<typename ObjectType, typename Recur> struct Op {
      template<typename Object, typename Functions, typename... Args>
      R operator ()(Object &object, const Functions &functions, Args&&... args)
      const {
         // Dynamic type test of object
         if (const auto pObject = dynamic_cast<ObjectType*>(&object))
            // Dispatch to an Executor that knows which of functions applies
            return Exec{}(*pObject, functions, std::forward<Args>(args)...);
         else
            // Recur, with fewer candidate Executors and all of functions
            return Recur{}(object, functions, std::forward<Args>(args)...);
      }
   };
public:
   template<typename Object, typename Functions, typename... Args>
   R operator ()(Object &object, const Functions &functions, Args&&... args)
   const {
      const auto fn = LeftFold_t<Op, ObjectTypes, Base>{};
      return fn(object, functions, std::forward<Args>(args)...);
   }
};
 
template<typename ...Executors> struct UsedCases {
   constexpr auto operator ()() {
      return std::integral_constant<unsigned, (Executors::SetUsed | ...)>{};
   };
};
 
template<size_t... Is, typename TupleLike> auto MakeFunctionTuple(
   std::index_sequence<Is...>, const TupleLike &functions) {
   return std::forward_as_tuple(std::get<Is>(functions)...);
}
 
template<
   typename R,
   typename ObjectTypes,
   typename Functions,
   typename... Args
>
struct TypeSwitcher {
   static_assert(!Null_v<ObjectTypes>);
   using Object = Head_t<ObjectTypes>;
   // Generate Executor classes, for each of ObjectTypes,
   // each zero-sized and with an operator () that calls the correct
   // one of functions, assuming the object is of the corresponding type
   template<typename Tail> using Executor_ =
      Executor_t<R, Tail, Functions, Args...>;
   using Executors = MapList_t<Fn<Executor_>, ObjectTypes>;
 
   // Compile time reachability check of the given functions
   enum { All = Length_v<Functions>, AllBits = (1u << All) - 1u };
   static_assert(std::is_same_v<
         std::integral_constant<unsigned, AllBits>,
         decltype(Apply_t<UsedCases, Executors>{}())
      >,
      "Uncallable case in TypeSwitch");
 
   using Exec = Apply_t<Callable::OverloadSet, Executors>;
   template<typename TupleLike> R operator ()(
      Object &object, const TupleLike &functions,
      Args&&... args) const {
      // Do dynamic dispatch to one of the Executors
      return Invoker<R, Exec, ObjectTypes>{}(object,
         MakeFunctionTuple(std::make_index_sequence<All>{}, functions),
         std::forward<Args>(args)...);
   }
};
 
template<typename TypeList> constexpr bool RootTypeCheck_v =
   Every_v<Bind1st<std::is_base_of, Head_t<TypeList>>, Tail_t<TypeList>>;
 
template<typename TypeList> using InheritanceCheck =
   NotAny<Bind2nd<std::is_base_of, Head_t<TypeList>>, Tail_t<TypeList>>;
 
}
 
template<typename TypeList> constexpr bool TypeListCheck_v =
   std::is_polymorphic_v<Head_t<TypeList>> &&
   detail::RootTypeCheck_v<TypeList> &&
   Every_v<Fn<detail::InheritanceCheck>, NonEmptyTails_t<TypeList>> &&
   (Every_v<Fn<std::is_const>, TypeList> ||
    NotAny_v<Fn<std::is_const>, TypeList>);
 
template<
   typename R = void,
   typename Types,
   class TupleLike,
   typename... Args
>
auto Dispatch(Head_t<Types> &object, const TupleLike &functions,
   Args&&... args)
   -> std::enable_if_t<TypeListCheck_v<Types>, R>
{
   // Generate a function that dispatches dynamically on track type
   return detail::TypeSwitcher<R, Types, Bind_t<TupleLike>, Args...>{}(
      object, functions, std::forward<Args>(args)...);
}
 
 
template<
   typename R = void,
   typename Types,
   typename ...Functions
>
auto VDispatch(Head_t<Types> &object, const Functions &...functions)
{
   return Dispatch<R, Types>(object, std::forward_as_tuple(functions...));
}
 
}
 
#endif