Bases.h

Go to the documentation of this file.

// This file's extension implies that it's C, but it's really -*- C++ -*-.
/*
 * Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration.
 */
 
 
#ifndef ATHENAKERNEL_BASES_H
#define ATHENAKERNEL_BASES_H
 
 
#include <type_traits>
 
 
namespace SG {
 

template <class T> struct Virtual {};
 
 
// Helper metafunction to get base class types.
// Generic case.
template <class T>
struct BaseType
{
  typedef T type;
  typedef std::false_type is_virtual;
};
 
 
// Helper metafunction to get base class types.
// Virtual derivation case.
template <class T>
struct BaseType<Virtual<T> >
{
  typedef T type;
  typedef std::true_type is_virtual;
};
 
 
// _t version to reduce typing.
template <class T>
using BaseType_t = typename SG::BaseType<T>::type;
 

struct NoBase {};
 

template <class... T>
struct BaseList
{
public:
  // First base in the list.
  using Base1 = NoBase;
 

  template <class CALLABLE>
  static
  auto foreach_ (CALLABLE f, bool /*is_virtual*/ = false)
  {
    // Need to find the return type.
    using return_t = decltype (f (static_cast<void*> (nullptr), false));
    return return_t (false);
  }
};
 

template <class T>
struct Bases
{
public:
  using bases = BaseList<>;
};
 

template <class BASE, class... REST>
struct BaseList<BASE, REST...>
{
public:
  // First base in the list.
  using Base1 = BASE;
 

  template <class CALLABLE>
  static
  auto foreach_ (CALLABLE f, bool is_virtual = false)
  {
    // Unwrap a SG::Virtual if needed.
    using base_t = typename BaseType<BASE>::type;
    const bool base_is_virtual = is_virtual || BaseType<BASE>::is_virtual::value;
 
    // Call the function on our first base.
    auto ret1 = f (static_cast<base_t*> (nullptr), base_is_virtual);
    if (static_cast<bool> (ret1)) {
      return ret1;
    }
 
    // Call it on bases of our first base.
    auto ret2 = Bases<base_t>::bases::foreach_ (f, base_is_virtual);
    if (static_cast<bool> (ret2)) {
      return ret2;
    }
 
    // Call it on our remaining bases.
    if constexpr (sizeof... (REST) > 0) {
      auto ret3 = BaseList<REST...>::foreach_ (f, is_virtual);
      if (static_cast<bool> (ret3)) {
        return ret3;
      }
    }
 
    // Got to the end; return false;
    using return_t = decltype (ret1);
    return return_t (false);
  }
};
 
 
} // namespace SG
 
 
#endif // not ATHENAKERNEL_BASES_H