visitValue.h

//
// Copyright 2022 Pixar
//
// Licensed under the terms set forth in the LICENSE.txt file available at
// https://openusd.org/license.
//
#ifndef PXR_BASE_VT_VISIT_VALUE_H
#define PXR_BASE_VT_VISIT_VALUE_H
 
#include "pxr/pxr.h"
 
#include "pxr/base/tf/meta.h"
#include "pxr/base/tf/pxrTslRobinMap/robin_map.h"
#include "pxr/base/tf/safeTypeCompare.h"
#include "pxr/base/vt/value.h"
 
#include <optional>
#include <typeinfo>
 
#ifndef VT_VISIT_VALUE_EXT_TYPES
#  define VT_VISIT_VALUE_EXT_TYPES PXR_NS_GLOBAL::TfMetaList<>
#endif
 
PXR_NAMESPACE_OPEN_SCOPE
 
namespace Vt_ValueVisitDetail {
 
// These two overloads do SFINAE to detect whether the visitor can be invoked
// with the given held type T.  If the visitor cannot be invoked with T, it is
// instead invoked with the VtValue itself.  We use the int/long trick and pass
// 0 in the caller to disambiguate in case both are viable.
template <class T, class Visitor, class ...Args>
auto
Visit(VtValue const &val, Visitor &&visitor, int, Args &&...args) ->
    decltype(std::forward<Visitor>(visitor)(
                 val.UncheckedGet<T>(), std::forward<Args>(args)...))
{
    return std::forward<Visitor>(visitor)(
        val.UncheckedGet<T>(), std::forward<Args>(args)...);
}
 
template <class T, class Visitor, class ...Args>
auto
Visit(VtValue const &val, Visitor &&visitor, long, Args &&...args) {
    return std::forward<Visitor>(visitor)(val, std::forward<Args>(args)...);
}
 
} // Vt_ValueVisitDetail
 
// Hash table mapping type_info -> index for extended type dispatch.
// Shared across all visitor types for the same type list.
template <class ...Ts>
struct Vt_ExtTypeIndexTable {
    static int Lookup(std::type_info const &ti) {
        static const Vt_ExtTypeIndexTable instance;
        auto it = instance._map.find(&ti);
        return (it != instance._map.end()) ? it->second : -1;
    }
private:
    struct _Hash {
        size_t operator()(std::type_info const *ti) const {
            return ti->hash_code();
        }
    };
    struct _Equal {
        bool operator()(std::type_info const *a,
                        std::type_info const *b) const {
            return TfSafeTypeCompare(*a, *b);
        }
    };
    Vt_ExtTypeIndexTable() {
        int idx = 0;
        ((_map.emplace(&typeid(Ts), idx++)), ...);
    }
    pxr_tsl::robin_map<std::type_info const *, int, _Hash, _Equal> _map;
};
 
// Helper: a single dispatch thunk for VtVisitValue, used in function pointer
// tables for large extended type lists.
template <class T, class Ret, class Visitor, class ...Args>
Ret
Vt_VisitValueExtDispatchOne(
    VtValue const &val, Visitor &&visitor, Args &&...args)
{
    return Vt_ValueVisitDetail::Visit<T>(
        val, std::forward<Visitor>(visitor), 0,
        std::forward<Args>(args)...);
}
 
constexpr size_t Vt_VisitValueHashThreshold = 8;
 
// Extended type dispatch for VtVisitValue.  For small type lists (<=
// Vt_VisitValueHashThreshold), uses a linear search via a short-circuiting fold
// expression.  For larger lists, uses a hash-table lookup + function-pointer
// dispatch.
template <class ...Ts, class Visitor, class ...Args>
auto
Vt_VisitValueExtDispatch(
    TfMetaList<Ts...>,
    VtValue const &val, Visitor &&visitor, Args &&...args)
{
    using Ret = decltype(
        Vt_ValueVisitDetail::Visit<VtValue>(
            val, std::forward<Visitor>(visitor), 0,
            std::forward<Args>(args)...));
 
    if constexpr (sizeof...(Ts) == 0) {
        return Vt_ValueVisitDetail::Visit<VtValue>(
            val, std::forward<Visitor>(visitor), 0,
            std::forward<Args>(args)...);
    }
    else if constexpr (sizeof...(Ts) <= Vt_VisitValueHashThreshold) {
        std::optional<Ret> result;
        ((!result && val.IsHolding<Ts>() &&
          (result.emplace(Vt_ValueVisitDetail::Visit<Ts>(
               val, std::forward<Visitor>(visitor), 0,
               std::forward<Args>(args)...)), true)) || ...);
        if (!result) {
            return Vt_ValueVisitDetail::Visit<VtValue>(
                val, std::forward<Visitor>(visitor), 0,
                std::forward<Args>(args)...);
        }
        return std::move(*result);
    }
    else {
        int idx = Vt_ExtTypeIndexTable<Ts...>::Lookup(val.GetTypeid());
        if (idx >= 0) {
            using FnPtr = Ret (*)(VtValue const &, Visitor &&, Args &&...);
            static constexpr FnPtr table[] = {
                &Vt_VisitValueExtDispatchOne<Ts, Ret, Visitor, Args...>...
            };
            return table[idx](
                val, std::forward<Visitor>(visitor),
                std::forward<Args>(args)...);
        }
        return Vt_ValueVisitDetail::Visit<VtValue>(
            val, std::forward<Visitor>(visitor), 0,
            std::forward<Args>(args)...);
    }
}
 
// Helper: dispatch thunk for VtVisitValueType.
template <class T, class Ret,
          template <class, class...> class Visitor, class ...TypeArgs,
          class ...FnArgs>
Ret
Vt_VisitValueTypeExtDispatchOne(FnArgs &&...args)
{
    return Visitor<T, TypeArgs...>::Visit(std::forward<FnArgs>(args)...);
}
 
// Extended type dispatch for VtVisitValueType.
template <template <class T, class ...> class Visitor, typename ...TypeArgs,
          class ...Ts, typename ...FnArgs>
auto
Vt_VisitValueTypeExtDispatch(
    TfMetaList<Ts...>,
    VtValue const &val, FnArgs &&...args)
{
    using Ret = decltype(
        Visitor<VtValue, TypeArgs...>::Visit(std::forward<FnArgs>(args)...));
 
    if constexpr (sizeof...(Ts) == 0) {
        return Visitor<VtValue, TypeArgs...>::Visit(
            std::forward<FnArgs>(args)...);
    }
    else if constexpr (sizeof...(Ts) <= Vt_VisitValueHashThreshold) {
        std::optional<Ret> result;
        ((!result && val.IsHolding<Ts>() &&
          (result.emplace(Visitor<Ts, TypeArgs...>::Visit(
               std::forward<FnArgs>(args)...)), true)) || ...);
        if (!result) {
            return Visitor<VtValue, TypeArgs...>::Visit(
                std::forward<FnArgs>(args)...);
        }
        return std::move(*result);
    }
    else {
        int idx = Vt_ExtTypeIndexTable<Ts...>::Lookup(val.GetTypeid());
        if (idx >= 0) {
            using FnPtr = Ret (*)(FnArgs &&...);
            static constexpr FnPtr table[] = {
                &Vt_VisitValueTypeExtDispatchOne<
                    Ts, Ret, Visitor, TypeArgs...>...
            };
            return table[idx](std::forward<FnArgs>(args)...);
        }
        return Visitor<VtValue, TypeArgs...>::Visit(
            std::forward<FnArgs>(args)...);
    }
}
 
// Helper: dispatch thunk for VtVisitValueType (template-template variant).
template <class T, class Ret,
          template <class, template <class...> class, class...> class Visitor,
          template <class...> class Tmpl, class ...TypeArgs,
          class ...FnArgs>
Ret
Vt_VisitValueTypeTmplExtDispatchOne(FnArgs &&...args)
{
    return Visitor<T, Tmpl, TypeArgs...>::Visit(std::forward<FnArgs>(args)...);
}
 
// Extended type dispatch for VtVisitValueType (template-template variant).
template <template <class T, template <class...> class, class ...> class Visitor,
          template <class...> class Tmpl, typename ...TypeArgs,
          class ...Ts, typename ...FnArgs>
auto
Vt_VisitValueTypeTmplExtDispatch(
    TfMetaList<Ts...>,
    VtValue const &val, FnArgs &&...args)
{
    using Ret = decltype(
        Visitor<VtValue, Tmpl, TypeArgs...>::Visit(
            std::forward<FnArgs>(args)...));
 
    if constexpr (sizeof...(Ts) == 0) {
        return Visitor<VtValue, Tmpl, TypeArgs...>::Visit(
            std::forward<FnArgs>(args)...);
    }
    else if constexpr (sizeof...(Ts) <= Vt_VisitValueHashThreshold) {
        std::optional<Ret> result;
        ((!result && val.IsHolding<Ts>() &&
          (result.emplace(Visitor<Ts, Tmpl, TypeArgs...>::Visit(
               std::forward<FnArgs>(args)...)), true)) || ...);
        if (!result) {
            return Visitor<VtValue, Tmpl, TypeArgs...>::Visit(
                std::forward<FnArgs>(args)...);
        }
        return std::move(*result);
    }
    else {
        int idx = Vt_ExtTypeIndexTable<Ts...>::Lookup(val.GetTypeid());
        if (idx >= 0) {
            using FnPtr = Ret (*)(FnArgs &&...);
            static constexpr FnPtr table[] = {
                &Vt_VisitValueTypeTmplExtDispatchOne<
                    Ts, Ret, Visitor, Tmpl, TypeArgs...>...
            };
            return table[idx](std::forward<FnArgs>(args)...);
        }
        return Visitor<VtValue, Tmpl, TypeArgs...>::Visit(
            std::forward<FnArgs>(args)...);
    }
}
 
 
template <class ExtTypes>
struct VtVisitValueWithExtTypes {
 
    template <class Visitor, class ...Args>
    static auto VisitValue(
        VtValue const &value, Visitor &&visitor, Args&&...args)
    {
        switch (value.GetKnownValueTypeIndex()) {
#define VT_CASE_FOR_TYPE_INDEX(unused, elem)                                   \
        case VtGetKnownValueTypeIndex<VT_TYPE(elem)>():                        \
            return Vt_ValueVisitDetail::Visit<VT_TYPE(elem)>(                  \
                value, std::forward<Visitor>(visitor), 0,                      \
                std::forward<Args>(args)...);                                  \
            break;
VT_FOR_EACH_VALUE_TYPE(VT_CASE_FOR_TYPE_INDEX)
#undef VT_CASE_FOR_TYPE_INDEX
        default:
            return Vt_VisitValueExtDispatch(
                ExtTypes{},
                value, std::forward<Visitor>(visitor),
                std::forward<Args>(args)...);
        };
    }
 
    template <
        template <class T, class ...> class Visitor,
        typename ...TypeArgs,
        typename ...FnArgs
        >
    static auto VisitType(VtValue const &value, FnArgs&&...args)
    {
        switch (value.GetKnownValueTypeIndex()) {
#define VT_CASE_FOR_TYPE_INDEX(unused, elem)                                   \
        case VtGetKnownValueTypeIndex<VT_TYPE(elem)>():                        \
            return Visitor<VT_TYPE(elem), TypeArgs...>::Visit(                 \
                std::forward<FnArgs>(args)...);                                \
            break;
VT_FOR_EACH_VALUE_TYPE(VT_CASE_FOR_TYPE_INDEX)
#undef VT_CASE_FOR_TYPE_INDEX
        default:
            return Vt_VisitValueTypeExtDispatch<Visitor, TypeArgs...>(
                ExtTypes{}, value, std::forward<FnArgs>(args)...);
        };
    }
 
    template <
        template <class T, template <class...> class, class ...> class Visitor,
        template <class...> class Tmpl,
        typename ...TypeArgs,
        typename ...FnArgs
        >
    static auto VisitType(VtValue const &value, FnArgs&&...args)
    {
        switch (value.GetKnownValueTypeIndex()) {
#define VT_CASE_FOR_TYPE_INDEX(unused, elem)                                   \
        case VtGetKnownValueTypeIndex<VT_TYPE(elem)>():                        \
            return Visitor<VT_TYPE(elem), Tmpl, TypeArgs...>::Visit(           \
                std::forward<FnArgs>(args)...);                                \
            break;
VT_FOR_EACH_VALUE_TYPE(VT_CASE_FOR_TYPE_INDEX)
#undef VT_CASE_FOR_TYPE_INDEX
        default:
            return Vt_VisitValueTypeTmplExtDispatch<Visitor, Tmpl, TypeArgs...>(
                ExtTypes{}, value, std::forward<FnArgs>(args)...);
        };
    }
};
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#ifdef doxygen
 
template <class Visitor, class ...Args>
auto VtVisitValue(VtValue const &value, Visitor &&visitor, Args &&...args);
 
template <
    template <class T, class ...> class Visitor,
    typename ...TypeArgs,
    typename ...FnArgs
    >
auto VtVisitValueType(VtValue const &value, FnArgs &&...args);
 
template <
    template <class T, template <class...> class, class ...> class Visitor,
    template <class...> class Tmpl,
    typename ...TypeArgs,
    typename ...FnArgs
    >
auto VtVisitValueType(VtValue const &value, FnArgs &&...args);
 
#else // !doxygen
 
#define VtVisitValue \
    VtVisitValueWithExtTypes<VT_VISIT_VALUE_EXT_TYPES>::VisitValue
 
#define VtVisitValueType \
    VtVisitValueWithExtTypes<VT_VISIT_VALUE_EXT_TYPES>::VisitType
 
#endif // doxygen
 
#endif // PXR_BASE_VT_VISIT_VALUE_H