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-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_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_PORT(identifier, ...) \
    this->template initInputArrayPort<NodeT, dw::framework::portIndex<NodeT, dw::framework::PortDirection::INPUT>(identifier)>(__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_PORT(identifier, ...) \
    this->template initOutputArrayPort<NodeT, dw::framework::portIndex<NodeT, dw::framework::PortDirection::OUTPUT>(identifier)>(__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
{
 
template <typename T>
class SimpleNodeT : public SimpleNode
{
public:
    using NodeT = T;
 
    SimpleNodeT()
        : SimpleNode(createAllocationParams<NodeT>())
    {
        initialize();
    }
 
    SimpleNodeT(NodeAllocationParams params)
        : SimpleNode(params)
    {
        initialize();
    }
 
    // TODO(chale): make final virtual once other users of this class are migrated.
    std::unique_ptr<Pass> createSetupPass() override
    {
        throw Exception(DW_CALL_NOT_ALLOWED, "Not meant to be called");
    }
 
    // TODO(chale): make final virtual once other users of this class are migrated.
    std::unique_ptr<Pass> createTeardownPass() override
    {
        throw Exception(DW_CALL_NOT_ALLOWED, "Not meant to be called");
    }
 
    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 Exception(DW_NOT_IMPLEMENTED, "Not implemented");
        }
 
        const PortCollectionDescriptor inputPorts = createPortCollectionDescriptor<NodeT, PortDirection::INPUT>();
        dwStatus status                           = SimpleNode::validate("input", inputPorts, getRegisteredInputPorts());
        if (status != DW_SUCCESS)
        {
            return status;
        }
        const PortCollectionDescriptor outputPorts = createPortCollectionDescriptor<NodeT, PortDirection::OUTPUT>();
        return SimpleNode::validate("output", outputPorts, getRegisteredOutputPorts(), inputPorts.getPortSize());
    }
 
private:
    void initialize()
    {
        NODE_REGISTER_PASS("SETUP"_sv, [this]() -> dwStatus {
            return setupImpl();
        });
        NODE_REGISTER_PASS("TEARDOWN"_sv, [this]() -> dwStatus {
            return teardownImpl();
        });
    }
};
 
template <typename T>
class SimpleSensorNodeT : public SimpleNodeT<T>, public SimpleSensorNode
{
};
 
template <typename T>
class SimpleProcessNodeT : public SimpleNodeT<T>
{
};
 
} // namespace framework
} // namespace dw
 
#endif // DW_FRAMEWORK_SIMPLENODET_HPP_