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-2023 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]
template <typename T>
// coverity[autosar_cpp14_a12_1_6_violation]
class SimpleNodeT : public SimpleNode
{
public:
    // coverity[autosar_cpp14_a0_1_6_violation]
    using NodeT = T;
 
    SimpleNodeT()
        : SimpleNode(createAllocationParams<NodeT>())
    {
        initialize();
    }
 
    SimpleNodeT(NodeAllocationParams params)
        : SimpleNode(params)
    {
        initialize();
    }
 
    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");
        }
 
        // coverity[autosar_cpp14_a18_5_8_violation]
        const PortCollectionDescriptor inputPortDescs{createPortCollectionDescriptor<NodeT, PortDirection::INPUT>()};
        // coverity[autosar_cpp14_a5_1_1_violation]
        dwStatus status{SimpleNode::validate("input", 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 (it->second.get() == nullptr)
                                                 {
                                                     throw ExceptionWithStatus(DW_NOT_INITIALIZED, "Input port was not initialized");
                                                 }
                                                 return it->second->isBound();
                                             })};
        if (status != DW_SUCCESS)
        {
            return status;
        }
        const PortCollectionDescriptor outputPortDescs{createPortCollectionDescriptor<NodeT, PortDirection::OUTPUT>()};
        size_t outputPortOffset{inputPortDescs.getPortSize()};
        // coverity[autosar_cpp14_a5_1_1_violation]
        return SimpleNode::validate("output", 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 (it->second.get() == nullptr)
                                        {
                                            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_