NodeFactory.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_NODEFACTORY_HPP_
#define DW_FRAMEWORK_NODEFACTORY_HPP_

#include <dwcgf/node/Node.hpp>

#include <dwcgf/logger/Logger.hpp>
#include <dwcgf/parameter/ParameterCollectionDescriptor.hpp>
#include <dwcgf/pass/PassCollectionDescriptor.hpp>
#include <dwcgf/port/PortCollectionDescriptor.hpp>

#include <dw/core/container/VectorFixed.hpp>
#include <dw/core/container/StringView.hpp>

#include <iostream>
#include <map>
#include <memory>
#include <mutex>

namespace dw
{
namespace framework
{

class Node;
class ParameterProvider;

namespace detail
{

class AbstractMetaObject
{
public:
    AbstractMetaObject(const dw::core::StringView className);

    virtual ~AbstractMetaObject() = default;

    const dw::core::StringView& className() const;

    virtual const PortCollectionDescriptor& getInputPorts() const = 0;

    virtual const PortCollectionDescriptor& getOutputPorts() const = 0;

    virtual const ParameterCollectionDescriptor& getParameters() const = 0;

    virtual const PassCollectionDescriptor& getPasses() const = 0;

    virtual std::unique_ptr<Node> create(ParameterProvider& provider) const = 0;

protected:
    dw::core::StringView m_className;
};

typedef std::map<dw::core::StringView, std::unique_ptr<AbstractMetaObject>> FactoryMap;

FactoryMap& getFactoryMap();

std::recursive_mutex& getFactoryMapMutex();

template <typename NodeT>
class MetaObject : public AbstractMetaObject
{
public:
    MetaObject(const dw::core::StringView className)
        : AbstractMetaObject(std::move(className))
    {
    }

    const PortCollectionDescriptor& getInputPorts() const override
    {
        static const PortCollectionDescriptor descriptor = createPortCollectionDescriptor<NodeT, PortDirection::INPUT>();
        return descriptor;
    }

    const PortCollectionDescriptor& getOutputPorts() const override
    {
        static const PortCollectionDescriptor descriptor = createPortCollectionDescriptor<NodeT, PortDirection::OUTPUT>();
        return descriptor;
    }

    const ParameterCollectionDescriptor& getParameters() const override
    {
        static const ParameterCollectionDescriptor descriptor = createParameterCollectionDescriptor<NodeT>();
        return descriptor;
    }

    const PassCollectionDescriptor& getPasses() const override
    {
        static const PassCollectionDescriptor descriptor = createPassCollectionDescriptor<NodeT>();
        return descriptor;
    }

    std::unique_ptr<Node> create(ParameterProvider& provider) const override
    {
        return NodeT::create(provider);
    }
};

} // namespace detail

template <typename NodeT>
void registerNode(const char* className)
{
    auto metaObject = std::make_unique<detail::MetaObject<NodeT>>(className);
    if (!metaObject)
    {
        throw Exception(DW_BAD_ALLOC, "NodeFactory: cannot allocate meta object");
    }

    std::lock_guard<std::recursive_mutex> lock(detail::getFactoryMapMutex());
    auto& factoryMap = detail::getFactoryMap();
    if (factoryMap.find(className) != factoryMap.end())
    {
        throw Exception(DW_INVALID_ARGUMENT, "registerNode() repeatedly called for the same class name: ", className);
    }
    else
    {
        factoryMap[className] = std::move(metaObject);
    }
}

dw::core::HeapVectorFixed<dw::core::StringView> getNodeNames();

const PortCollectionDescriptor& getInputPorts(const dw::core::StringView& className);

const PortCollectionDescriptor& getOutputPorts(const dw::core::StringView& className);

const ParameterCollectionDescriptor& getParameters(const dw::core::StringView& className);

const PassCollectionDescriptor& getPasses(const dw::core::StringView& className);

std::unique_ptr<Node> createNode(const dw::core::StringView& className, ParameterProvider& provider);

} // namespace framework
} // namespace dw

#define _DW_REGISTER_NODE_WITH_SUFFIX(NodeT, UniqueSuffix)   \
    namespace                                                \
    {                                                        \
    struct Proxy##UniqueSuffix                               \
    {                                                        \
        Proxy##UniqueSuffix()                                \
        {                                                    \
            dw::framework::registerNode<NodeT>(#NodeT);      \
        }                                                    \
    };                                                       \
    static Proxy##UniqueSuffix g_registerNode##UniqueSuffix; \
    } // namespace

#define _DW_REGISTER_NODE(NodeT) \
    _DW_REGISTER_NODE_WITH_SUFFIX(NodeT, UniqueSuffix)

#define _DW_REGISTER_NODE_GET_3RD_ARG(arg1, arg2, arg3, ...) arg3
#define _DW_REGISTER_NODE_MACRO_CHOOSER(...) \
    _DW_REGISTER_NODE_GET_3RD_ARG(__VA_ARGS__, _DW_REGISTER_NODE_WITH_SUFFIX, _DW_REGISTER_NODE, )

#define DW_REGISTER_NODE(...)                    \
    _DW_REGISTER_NODE_MACRO_CHOOSER(__VA_ARGS__) \
    (__VA_ARGS__)

#endif //DW_FRAMEWORK_NODEFACTORY_HPP_