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 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>
// Output parameter is used to populate collection without making collection know about where the information is coming from
// coverity[autosar_cpp14_a8_4_8_violation]
void addPassDescriptor(PassCollectionDescriptor& collection)
{
    (void)collection;
}

template <
    typename NodeT, size_t Index,
    typename std::enable_if_t<Index<passSize<NodeT>(), void>* = nullptr>
    // Output parameter is used to populate collection without making collection know about where the information is coming from
    // coverity[autosar_cpp14_a8_4_8_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_