SimpleNodeT.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-2024 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_SIMPLENODET_HPP_
#define DW_FRAMEWORK_SIMPLENODET_HPP_
 
#include <dwcgf/node/SimpleNode.hpp>
#include <dwcgf/pass/PassDescriptor.hpp>
#include <dwcgf/port/PortCollectionDescriptor.hpp>
#include <dwcgf/port/PortDescriptor.hpp>
 
#define NODE_GET_INPUT_PORT_INDEX(identifier) dw::framework::portIndex<NodeT, dw::framework::PortDirection::INPUT>(identifier)
#define NODE_GET_OUTPUT_PORT_INDEX(identifier) dw::framework::portIndex<NodeT, dw::framework::PortDirection::OUTPUT>(identifier)
 
 
#define NODE_REGISTER_PASS(identifier, ...) this->template registerPass<NodeT, dw::framework::passIndex<NodeT>(identifier)>(__VA_ARGS__)
 
 
#define NODE_INIT_INPUT_PORT(identifier, ...) \
    this->template initInputPort<NodeT, dw::framework::portIndex<NodeT, dw::framework::PortDirection::INPUT>(identifier)>(__VA_ARGS__)
 
#define NODE_INIT_INPUT_ARRAY_PORTS(identifier, ...) \
    this->template initInputArrayPorts<NodeT, dw::framework::portIndex<NodeT, dw::framework::PortDirection::INPUT>(identifier)>(__VA_ARGS__)
 
#define NODE_INIT_INPUT_ARRAY_PORT(identifier, arrayIndex, ...) \
    this->template initInputArrayPort<NodeT, dw::framework::portIndex<NodeT, dw::framework::PortDirection::INPUT>(identifier)>(arrayIndex, ##__VA_ARGS__)
 
#define NODE_INIT_OUTPUT_PORT(identifier, ...) \
    this->template initOutputPort<NodeT, dw::framework::portIndex<NodeT, dw::framework::PortDirection::OUTPUT>(identifier)>(__VA_ARGS__)
 
#define NODE_INIT_OUTPUT_ARRAY_PORTS(identifier, ...) \
    this->template initOutputArrayPorts<NodeT, dw::framework::portIndex<NodeT, dw::framework::PortDirection::OUTPUT>(identifier)>(__VA_ARGS__)
 
#define NODE_INIT_OUTPUT_ARRAY_PORT(identifier, arrayIndex, ...) \
    this->template initOutputArrayPort<NodeT, dw::framework::portIndex<NodeT, dw::framework::PortDirection::OUTPUT>(identifier)>(arrayIndex, ##__VA_ARGS__)
 
 
#define NODE_GET_INPUT_PORT(identifier) this->template getInputPort<NodeT, NODE_GET_INPUT_PORT_INDEX(identifier)>()
 
#define NODE_GET_INPUT_ARRAY_PORT(identifier, index) this->template getInputPort<NodeT, NODE_GET_INPUT_PORT_INDEX(identifier)>(index)
 
#define NODE_GET_OUTPUT_PORT(identifier) this->template getOutputPort<NodeT, NODE_GET_OUTPUT_PORT_INDEX(identifier)>()
 
#define NODE_GET_OUTPUT_ARRAY_PORT(identifier, index) this->template getOutputPort<NodeT, NODE_GET_OUTPUT_PORT_INDEX(identifier)>(index)
 
namespace dw
{
namespace framework
{
 
// coverity[autosar_cpp14_a14_1_1_violation] FP: nvbugs/4356873
template <typename T>
// coverity[autosar_cpp14_a12_1_6_violation] FP: nvbugs/4016780
class SimpleNodeT : public SimpleNode
{
public:
    // coverity[autosar_cpp14_a0_1_6_violation]
    using NodeT = T;
 
    SimpleNodeT()
        : SimpleNodeT(createAllocationParams<NodeT>())
    {
    }
 
    SimpleNodeT(NodeAllocationParams params)
        : SimpleNode(params)
    {
        initialize();
    }
 
    // coverity[autosar_cpp14_a12_7_1_violation] FP: nvbugs/4356873
    ~SimpleNodeT()
    {
        // can't be checked within class scope since
        // a concrete class MyClass might want to inherit from SimpleNodeT<MyClass>
        // at which point T is an incomplete type in the class scope
        static_assert(std::is_base_of<Node, T>::value, "T must inherit from Node");
    }
 
    virtual dwStatus setupImpl()
    {
        return this->setup();
    }
 
    virtual dwStatus teardownImpl()
    {
        return this->teardown();
    }
 
    dwStatus reset() override
    {
        this->resetPorts();
        return DW_SUCCESS;
    }
 
    dwStatus validate() override
    {
        if (getRegisteredInputPorts().empty() && getRegisteredOutputPorts().empty())
        {
            throw ExceptionWithStatus(DW_NOT_IMPLEMENTED, "Not implemented");
        }
 
        const char* INPUT_DIRECTION{"input"};
        // coverity[autosar_cpp14_a18_5_8_violation] FP: nvbugs/3498833
        const PortCollectionDescriptor inputPortDescs{createPortCollectionDescriptor<NodeT, PortDirection::INPUT>()};
        dwStatus status{SimpleNode::validate(
            INPUT_DIRECTION, inputPortDescs,
            [&](size_t portIdx) -> bool {
                const dw::core::HeapHashMap<size_t, std::shared_ptr<ManagedPortInputBase>>& registeredPorts{getRegisteredInputPorts()};
                dw::core::HeapHashMap<size_t, std::shared_ptr<ManagedPortInputBase>>::const_iterator it{registeredPorts.find(portIdx)};
                if (it == registeredPorts.end())
                {
                    throw ExceptionWithStatus(DW_NOT_IMPLEMENTED, "Input port was not registered");
                }
                if (nullptr == it->second.get())
                {
                    throw ExceptionWithStatus(DW_NOT_INITIALIZED, "Input port was not initialized");
                }
                return it->second->isBound();
            })};
        // LCOV_EXCL_START defensive code can't be triggered since SimpleNode::validate() always returns success or throws
        if (DW_SUCCESS != status)
        {
            return status;
        }
        // LCOV_EXCL_STOP
        const char* OUTPUT_DIRECTION{"output"};
        const PortCollectionDescriptor outputPortDescs{createPortCollectionDescriptor<NodeT, PortDirection::OUTPUT>()};
        size_t outputPortOffset{inputPortDescs.getPortSize()};
        return SimpleNode::validate(
            OUTPUT_DIRECTION, outputPortDescs,
            [&](size_t portIdx) -> bool {
                const dw::core::HeapHashMap<size_t, std::shared_ptr<ManagedPortOutputBase>>& registeredPorts{getRegisteredOutputPorts()};
                dw::core::HeapHashMap<size_t, std::shared_ptr<ManagedPortOutputBase>>::const_iterator it{registeredPorts.find(portIdx + outputPortOffset)};
                if (it == registeredPorts.end())
                {
                    throw ExceptionWithStatus(DW_NOT_IMPLEMENTED, "Output port was not registered");
                }
                if (nullptr == it->second.get())
                {
                    throw ExceptionWithStatus(DW_NOT_INITIALIZED, "Output port was not initialized");
                }
                return it->second->isBound();
            });
    }
 
private:
    void initialize()
    {
        NODE_REGISTER_PASS("SETUP"_sv, [this]() -> dwStatus {
            return setupImpl();
        },
                           {{DW_NOT_AVAILABLE, 0U}});
        NODE_REGISTER_PASS("TEARDOWN"_sv, [this]() -> dwStatus {
            return teardownImpl();
        });
    }
};
 
} // namespace framework
} // namespace dw
 
#endif // DW_FRAMEWORK_SIMPLENODET_HPP_