typeDispatchTable.h

Go to the documentation of this file.

//
// Copyright 2025 Pixar
//
// Licensed under the terms set forth in the LICENSE.txt file available at
// https://openusd.org/license.
//
#ifndef PXR_EXEC_VDF_TYPE_DISPATCH_TABLE_H
#define PXR_EXEC_VDF_TYPE_DISPATCH_TABLE_H
 
 
 
#include "pxr/pxr.h"
 
#include "pxr/exec/vdf/api.h"
 
#include "pxr/base/tf/hash.h"
#include "pxr/base/tf/pxrTslRobinMap/robin_map.h"
#include "pxr/base/tf/type.h"
 
#include <tbb/spin_rw_mutex.h>
 
#include <typeinfo>
#include <utility>
 
PXR_NAMESPACE_OPEN_SCOPE
 
// Non-template-dependent part of dispatch table implementation.
class Vdf_TypeDispatchTableBase
{
public:
    VDF_API
    bool IsTypeRegistered(TfType t) const;
 
protected:
    VDF_API
    bool _RegisterType(const std::type_info &ti, void *f);
 
    VDF_API
    void *_FindOrFatalError(TfType t) const;
 
    VDF_API
    Vdf_TypeDispatchTableBase();
 
    VDF_API
    ~Vdf_TypeDispatchTableBase();
 
private:
    // Type for the dispatch map, a map from keys to functions.
    using _MapType = pxr_tsl::robin_map<TfType, void *, TfHash>;
 
    // The type dispatch map.
    _MapType _map;
 
    // Guards the hash table buckets.
    mutable tbb::spin_rw_mutex _mutex;
};
 
 
template <template <typename> class Fn>
class VdfTypeDispatchTable
    : public Vdf_TypeDispatchTableBase
{
public:
    using FnSignature = decltype(Fn<int>::Call);
 
    template <typename Type>
    bool RegisterType()
    {
        // Instantiate Fn for the given type, and put a pointer to it in
        // the type dispatch map.
        const std::type_info &ti = typeid(Type);
        FnSignature *f = &Fn<Type>::Call;
        return _RegisterType(ti, reinterpret_cast<void *>(f));
    }
 
    template <typename RetType, typename... Args>
    RetType Call(TfType key, Args&&... args) const
    {
        return reinterpret_cast<FnSignature *>(this->_FindOrFatalError(key))
            (std::forward<Args>(args)...);
    }
};
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif