rtti_utils.h

/*
Copyright 2024-present Intel Corporation.
 
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
 
    http://www.apache.org/licenses/LICENSE-2.0
 
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
 
 
#ifndef LIB_RTTI_UTILS_H_
#define LIB_RTTI_UTILS_H_
 
#include <type_traits>
 
#include "rtti.h"
 
namespace P4::RTTI {
 
template <typename T>
struct has_rtti : std::is_base_of<RTTI::Base, T> {};
 
template <typename T>
inline constexpr const bool has_rtti_v = has_rtti<T>::value;
 
template <typename... Ts>
inline constexpr const bool all_have_rtti_v = (has_rtti_v<Ts> && ...);
 
template <typename T, typename R = void>
struct enable_if_has_rtti : std::enable_if<has_rtti_v<T>, R> {};
 
template <typename... Ts>
using enable_if_all_have_rtti_t = std::enable_if_t<all_have_rtti_v<Ts...>, void>;
 
template <typename T, typename R = void>
using enable_if_has_rtti_t = typename enable_if_has_rtti<T, R>::type;
 
namespace Detail {
 
template <typename To, typename = enable_if_has_rtti_t<To>>
struct ToType {
    template <typename From, typename = enable_if_has_rtti_t<From>>
    To *operator()(From *obj) const {
        return obj ? obj->template to<To>() : nullptr;
    }
 
    template <typename From, typename = enable_if_has_rtti_t<From>>
    const To *operator()(const From *obj) const {
        return obj ? obj->template to<To>() : nullptr;
    }
};
 
template <typename... Targets>
// TODO(C++20): use concepts to check enable_if_all_have_rtti_t<Targets...>> & that there is at
// least 1 target type.
struct IsType {
    static_assert(sizeof...(Targets) > 0,
                  "At least one target type needs to be given for RTTI::is");
    static_assert(all_have_rtti_v<Targets...>,
                  "All types in RTTI::is<Ts> need to be custom-rtti-enabled");
 
    template <typename From, typename = enable_if_has_rtti_t<From>>
    bool operator()(const From *obj) const {
        return obj && (obj->template is<Targets>() || ...);
    }
};
 
}  // namespace Detail
 
template <typename To>
inline const Detail::ToType<To> to;
 
template <typename Target>
inline const Detail::IsType<Target> is;
 
template <typename... Targets>
inline const Detail::IsType<Targets...> isAny;
 
}  // namespace P4::RTTI
 
#endif  // LIB_RTTI_UTILS_H_