TypeBasedParameterProvider.hpp

Go to the documentation of this file.

 
//
// Notice
// ALL NVIDIA DESIGN SPECIFICATIONS AND CODE ("MATERIALS") ARE PROVIDED "AS IS" NVIDIA MAKES
// NO REPRESENTATIONS, WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
// THE MATERIALS, AND EXPRESSLY DISCLAIMS ANY IMPLIED WARRANTIES OF NONINFRINGEMENT,
// MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
//
// NVIDIA CORPORATION & AFFILIATES assumes no responsibility for the consequences of use of such
// information or for any infringement of patents or other rights of third parties that may
// result from its use. No license is granted by implication or otherwise under any patent
// or patent rights of NVIDIA CORPORATION & AFFILIATES. No third party distribution is allowed unless
// expressly authorized by NVIDIA. Details are subject to change without notice.
// This code supersedes and replaces all information previously supplied.
// NVIDIA CORPORATION & AFFILIATES products are not authorized for use as critical
// components in life support devices or systems without express written approval of
// NVIDIA CORPORATION & AFFILIATES.
//
// SPDX-FileCopyrightText: Copyright (c) 2021-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
// SPDX-License-Identifier: LicenseRef-NvidiaProprietary
//
// NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
// property and proprietary rights in and to this material, related
// documentation and any modifications thereto. Any use, reproduction,
// disclosure or distribution of this material and related documentation
// without an express license agreement from NVIDIA CORPORATION or
// its affiliates is strictly prohibited.
//
 
#ifndef DW_FRAMEWORK_TYPEBASEDPARAMETERPROVIDER_HPP_
#define DW_FRAMEWORK_TYPEBASEDPARAMETERPROVIDER_HPP_
 
#include <dwcgf/parameter/ParameterProvider.hpp>
 
#include <dw/core/container/VectorFixed.hpp>
#include <dwcgf/Exception.hpp>
 
#include <typeindex>
#include <utility>
 
namespace dw
{
namespace framework
{
 
class TypeBasedParameterProvider;
 
class ITypeBasedParameterProviderChild
{
protected:
    ITypeBasedParameterProviderChild(ITypeBasedParameterProviderChild const&) = default;
    ITypeBasedParameterProviderChild(ITypeBasedParameterProviderChild&&) = default;
    ITypeBasedParameterProviderChild& operator=(ITypeBasedParameterProviderChild const&) & = default;
    ITypeBasedParameterProviderChild& operator=(ITypeBasedParameterProviderChild&&) & = default;
 
public:
    ITypeBasedParameterProviderChild() = default;
    virtual ~ITypeBasedParameterProviderChild() = default;
    virtual void registerAt(TypeBasedParameterProvider& provider) const = 0;
};
 
class TypeBasedParameterProvider : public ParameterProvider
{
protected:
    TypeBasedParameterProvider(TypeBasedParameterProvider const&) = default;
    TypeBasedParameterProvider(TypeBasedParameterProvider&&) = default;
    TypeBasedParameterProvider& operator=(TypeBasedParameterProvider const&) & = default;
    TypeBasedParameterProvider& operator=(TypeBasedParameterProvider&&) & = default;
 
public:
    TypeBasedParameterProvider() = default;
    ~TypeBasedParameterProvider() override = default;
 
    bool get(
        ParameterProvider const* const parentProvider,
        dw::core::StringView const& key,
        const std::type_info& semanticTypeInfo,
        const std::type_info& dataTypeInfo,
        void* out) const override;
 
    bool get(
        ParameterProvider const* const parentProvider,
        dw::core::StringView const& key,
        size_t const index,
        const std::type_info& semanticTypeInfo,
        const std::type_info& dataTypeInfo,
        void* out) const override;
 
    template <typename T>
    void registerProvider(const ParameterProvider* provider)
    {
        registerProvider(typeid(T), provider);
    }
 
    template <typename T>
    const ParameterProvider* getProvider() const
    {
        return getProvider(typeid(T));
    }
 
protected:
    void registerProvider(const std::type_info& typeInfo, const ParameterProvider* provider);
 
    const ParameterProvider* getProvider(const std::type_info& typeInfo) const;
 
private:
    // Can't use std::type_index since on QNX two type_info/index of the same type
    // might not compare equal to each other / have different hashes
    dw::core::VectorFixed<std::pair<const std::type_info&, const ParameterProvider*>, 256> m_providers;
 
public:
    template <typename T>
    void registerProviderChild(const T& providerChild)
    {
        registerProviderChild(typeid(T), providerChild);
    }
 
    template <typename T>
    const ITypeBasedParameterProviderChild* getProviderChild() const
    {
        return getProviderChild(typeid(T));
    }
 
    void registerProviderChild(const std::type_info& typeInfo, const ITypeBasedParameterProviderChild& providerChild);
 
protected:
    const ITypeBasedParameterProviderChild* getProviderChild(const std::type_info& typeInfo) const;
 
private:
    // Can't use std::type_index since on QNX two type_info/index of the same type
    // might not compare equal to each other / have different hashes
    dw::core::VectorFixed<std::pair<const std::type_info&, const ITypeBasedParameterProviderChild&>, 256> m_providerChildren;
 
public:
    using ParameterByNameHandler = std::function<bool(dw::core::StringView const&, void*)>;
 
    template <typename T>
    void registerByNameHandler(ParameterByNameHandler&& handler)
    {
        registerByNameHandler<T, T>(std::move(handler));
    }
 
    template <typename T, typename S>
    void registerByNameHandler(ParameterByNameHandler&& handler)
    {
        registerByNameHandler(typeid(T), typeid(S), std::move(handler));
    }
 
protected:
    void registerByNameHandler(const std::type_info& dataTypeInfo, const std::type_info& semanticTypeInfo, ParameterByNameHandler&& handler);
 
    ParameterByNameHandler const* getByNameHandler(const std::type_info& dataTypeInfo, const std::type_info& semanticTypeInfo) const;
 
private:
    // Can't use std::type_index since on QNX two type_info/index of the same type
    // might not compare equal to each other / have different hashes
    dw::core::VectorFixed<std::pair<std::pair<const std::type_info&, const std::type_info&>, ParameterByNameHandler>, 256> m_byNameHandlers;
 
public:
    using ParameterByNameAndIndexHandler = std::function<bool(dw::core::StringView const&, size_t, void*)>;
 
    template <typename T>
    void registerByNameAndIndexHandler(ParameterByNameAndIndexHandler&& handler)
    {
        registerByNameAndIndexHandler<T, T>(std::move(handler));
    }
 
    template <typename T, typename S>
    void registerByNameAndIndexHandler(ParameterByNameAndIndexHandler&& handler)
    {
        registerByNameAndIndexHandler(typeid(T), typeid(S), std::move(handler));
    }
 
protected:
    void registerByNameAndIndexHandler(const std::type_info& dataTypeInfo, const std::type_info& semanticTypeInfo, ParameterByNameAndIndexHandler&& handler);
 
    ParameterByNameAndIndexHandler const* getByNameAndIndexHandler(const std::type_info& dataTypeInfo, const std::type_info& semanticTypeInfo) const;
 
private:
    // Can't use std::type_index since on QNX two type_info/index of the same type
    // might not compare equal to each other / have different hashes
    dw::core::VectorFixed<std::pair<std::pair<const std::type_info&, const std::type_info&>, ParameterByNameAndIndexHandler>, 256> m_byNameAndIndexHandlers;
 
public:
    using ParameterByIndexHandler = std::function<bool(size_t, void*)>;
 
    template <typename T>
    void registerByIndexHandler(ParameterByIndexHandler&& handler)
    {
        registerByIndexHandler<T, T>(std::move(handler));
    }
 
    template <typename T, typename S>
    void registerByIndexHandler(ParameterByIndexHandler&& handler)
    {
        registerByIndexHandler(typeid(T), typeid(S), std::move(handler));
    }
 
protected:
    void registerByIndexHandler(const std::type_info& dataTypeInfo, const std::type_info& semanticTypeInfo, ParameterByIndexHandler&& handler);
 
    ParameterByIndexHandler const* getByIndexHandler(const std::type_info& dataTypeInfo, const std::type_info& semanticTypeInfo) const;
 
private:
    // Can't use std::type_index since on QNX two type_info/index of the same type
    // might not compare equal to each other / have different hashes
    dw::core::VectorFixed<std::pair<std::pair<const std::type_info&, const std::type_info&>, ParameterByIndexHandler>, 256> m_byIndexHandlers;
 
public:
    using ParameterByTypeHandler = std::function<bool(void*)>;
 
    template <typename T>
    void registerByTypeHandler(ParameterByTypeHandler&& handler)
    {
        registerByTypeHandler<T, T>(std::move(handler));
    }
 
    template <typename T, typename S>
    void registerByTypeHandler(ParameterByTypeHandler&& handler)
    {
        registerByTypeHandler(typeid(T), typeid(S), std::move(handler));
    }
 
protected:
    void registerByTypeHandler(const std::type_info& dataTypeInfo, const std::type_info& semanticTypeInfo, ParameterByTypeHandler&& handler);
 
    ParameterByTypeHandler const* getByTypeHandler(const std::type_info& dataTypeInfo, const std::type_info& semanticTypeInfo) const;
 
private:
    // Can't use std::type_index since on QNX two type_info/index of the same type
    // might not compare equal to each other / have different hashes
    dw::core::VectorFixed<std::pair<std::pair<const std::type_info&, const std::type_info&>, ParameterByTypeHandler>, 256> m_byTypeHandlers;
 
protected:
    static bool isPairEqual(const std::pair<const std::type_info&, const std::type_info&>& lhs, const std::pair<const std::type_info&, const std::type_info&>& rhs);
};
 
} // namespace framework
} // namespace dw
 
#endif // DW_FRAMEWORK_TYPEBASEDPARAMETERPROVIDER_HPP_