MatchType.hpp

Go to the documentation of this file.

/*
 * Copyright 2025 Helge Bahmann <hcb@chaoticmind.net>
 * See COPYING for terms of redistribution.
 */
 
#ifndef JLM_RVSDG_MATCH_TYPE_HPP
#define JLM_RVSDG_MATCH_TYPE_HPP
 
#include <stdexcept>
#include <string>
#include <tuple>
 
namespace jlm::rvsdg
{
 
template<typename MFP>
struct member_function_pointer_argtype;
 
// Partial specialization to deduce type from non-const member function pointers.
template<typename MFP, typename Ret, typename... Args>
struct member_function_pointer_argtype<Ret (MFP::*)(Args...)>
{
  // Deduce for non-const member functions.
  using type = std::tuple_element_t<0, std::tuple<Args...>>;
};
 
// Partial specialization to deduce type from const member function pointers.
template<typename MFP, typename Ret, typename... Args>
struct member_function_pointer_argtype<Ret (MFP::*)(Args...) const>
{
  // Deduce for const member functions.
  using type = std::tuple_element_t<0, std::tuple<Args...>>;
};
 
template<typename MFP>
struct member_function_pointer_restype;
 
// Partial specialization to deduce type from non-const member function pointers.
template<typename MFP, typename Ret, typename... Args>
struct member_function_pointer_restype<Ret (MFP::*)(Args...)>
{
  // Deduce for non-const member functions.
  using type = Ret;
};
 
// Partial specialization to deduce type from const member function pointers.
template<typename MFP, typename Ret, typename... Args>
struct member_function_pointer_restype<Ret (MFP::*)(Args...) const>
{
  // Deduce for const member functions.
  using type = Ret;
};
 
template<typename Callable>
struct CallableArgumentType
{
  // Deduce for object types.
  using type = typename member_function_pointer_argtype<decltype(&Callable::operator())>::type;
};
 
// Partial specialization to deduce if callabale object is a function pointer type.
template<typename Ret, typename... Args>
struct CallableArgumentType<Ret(Args...)>
{
  // Specialization to deduce for function pointer types.
  using type = std::tuple_element_t<0, std::tuple<Args...>>;
};
 
template<typename Callable>
struct CallableResultType
{
  // Deduce for object types.
  using type = typename member_function_pointer_restype<decltype(&Callable::operator())>::type;
};
 
// Partial specialization to deduce if callable object is a function pointer type.
template<typename Ret, typename... Args>
struct CallableResultType<Ret(Args...)>
{
  // Specialization to deduce for function pointer types.
  using type = Ret;
};
 
template<typename T, typename... Fns>
void
MatchType(T & obj, const Fns &... fns);
 
// Specialization to handle the termination (empty handlers) case.
template<typename T>
void
MatchType(T & x)
{}
 
// Specialization to handle the head case.
template<typename T, typename Fn, typename... Fns>
void
MatchType(T & x, const Fn & fn, const Fns &... fns)
{
  using S = std::remove_reference_t<typename CallableArgumentType<Fn>::type>;
  if (auto i = dynamic_cast<S *>(&x))
  {
    fn(*i);
  }
  else
  {
    MatchType(x, fns...);
  }
};
 
template<typename T, typename... Fns>
void
MatchTypeWithDefault(T & obj, const Fns &... fns);
 
// Specialization to handle the termination (empty handlers) case.
template<typename T, typename Fn>
typename CallableResultType<Fn>::type
MatchTypeWithDefault(T & /* x */, const Fn & fn)
{
  return fn();
}
 
// Specialization to handle the head case.
template<typename T, typename Fn, typename... Fns>
typename CallableResultType<Fn>::type
MatchTypeWithDefault(T & x, const Fn & fn, const Fns &... fns)
{
  using S = std::remove_reference_t<typename CallableArgumentType<Fn>::type>;
  if (auto i = dynamic_cast<S *>(&x))
  {
    return fn(*i);
  }
  else
  {
    return MatchTypeWithDefault(x, fns...);
  }
};
 
template<typename T, typename... Fns>
void
MatchTypeOrFail(T & obj, const Fns &... fns);
 
// Specialization to handle the termination (last handler) case.
template<typename T, typename Fn>
typename CallableResultType<Fn>::type
MatchTypeOrFail(T & x, const Fn & fn)
{
  using S = std::remove_reference_t<typename CallableArgumentType<Fn>::type>;
  if (auto i = dynamic_cast<S *>(&x))
  {
    return fn(*i);
  }
  else
  {
    throw std::logic_error(std::string("Incomplete pattern matching on ") + typeid(T).name());
  }
}
 
// Specialization to handle the head case.
template<typename T, typename Fn, typename... Fns>
typename CallableResultType<Fn>::type
MatchTypeOrFail(T & x, const Fn & fn, const Fns &... fns)
{
  using S = std::remove_reference_t<typename CallableArgumentType<Fn>::type>;
  if (auto i = dynamic_cast<S *>(&x))
  {
    return fn(*i);
  }
  else
  {
    return MatchTypeOrFail(x, fns...);
  }
};
 
}
 
#endif