PassCollectionDescriptor.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_PASSCOLLECTIONDESCRIPTOR_HPP_
#define DW_FRAMEWORK_PASSCOLLECTIONDESCRIPTOR_HPP_
 
#include <dwcgf/pass/PassDescriptor.hpp>
 
#include <dw/core/container/VectorFixed.hpp>
 
namespace dw
{
namespace framework
{
 
class PassDescriptor
{
public:
    PassDescriptor(dw::core::StringView const& name, dwProcessorType const processorType, const bool hasExplicitDependencies, size_t const dependencies);
 
    dw::core::StringView const& getName() const noexcept;
 
    dwProcessorType getProcessorType() const noexcept;
 
    bool hasExplicitDependencies() const noexcept;
 
    size_t getNumberOfDependencies() const;
 
    dw::core::StringView const& getDependency(size_t const index) const;
 
    void addDependency(dw::core::StringView const& dependency);
 
private:
    dw::core::StringView m_name;
    dwProcessorType m_processorType;
    bool m_hasExplicitDependencies;
    dw::core::VectorFixed<dw::core::StringView> m_dependencies;
};
 
class PassCollectionDescriptor
{
public:
    explicit PassCollectionDescriptor(size_t const capacity);
 
    size_t getSize() const;
 
    const PassDescriptor& getDescriptor(size_t const index) const;
 
    size_t getIndex(dw::core::StringView const& identifier) const;
 
    const PassDescriptor& getDescriptor(dw::core::StringView const& identifier) const;
 
    bool isValid(size_t const index) const noexcept;
 
    bool isValid(dw::core::StringView const& identifier) const noexcept;
 
    void addDescriptor(const PassDescriptor& descriptor);
 
private:
    dw::core::VectorFixed<PassDescriptor> m_descriptors;
};
 
namespace detail
{
 
template <
    typename NodeT, size_t Index,
    typename std::enable_if_t<Index == passSize<NodeT>(), void>* = nullptr>
void addPassDescriptor(PassCollectionDescriptor& collection)
{
    (void)collection;
}
 
template <
    typename NodeT, size_t Index,
    typename std::enable_if_t<Index<passSize<NodeT>(), void>* = nullptr>
    // TODO(dwplc): FP -- The specific specialization of this templated function is selected by enable_if
    // coverity[autosar_cpp14_a2_10_5_violation]
    void addPassDescriptor(PassCollectionDescriptor& collection)
{
    constexpr auto dependencies = passDependencies<NodeT, Index>();
    PassDescriptor descriptor(passName<NodeT, Index>(), passProcessorType<NodeT, Index>(), hasPassDependencies<NodeT, Index>(), dependencies.size());
    for (size_t i = 0; i < dependencies.size(); ++i)
    {
        descriptor.addDependency(dependencies[i]);
    }
    collection.addDescriptor(descriptor);
 
    addPassDescriptor<NodeT, Index + 1>(collection);
}
 
} // namespace detail
 
template <typename NodeT>
static PassCollectionDescriptor createPassCollectionDescriptor()
{
    PassCollectionDescriptor collection(passSize<NodeT>());
    detail::addPassDescriptor<NodeT, 0>(collection);
    return collection;
}
 
} // namespace framework
} // namespace dw
 
#endif // DW_FRAMEWORK_PASSCOLLECTIONDESCRIPTOR_HPP_