PortCollectionDescriptor.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_PORTCOLLECTIONDESCRIPTOR_HPP_
#define DW_FRAMEWORK_PORTCOLLECTIONDESCRIPTOR_HPP_

#include <dwcgf/port/Port.hpp>
#include <dwcgf/port/PortDescriptor.hpp>

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

#include <string>
#include <typeinfo>

#define NODE_GET_INPUT_PORT_INDEX_EXTERNAL(NodeT, identifier) dw::framework::portIndex<NodeT, dw::framework::PortDirection::INPUT>(identifier)
#define NODE_GET_OUTPUT_PORT_INDEX_EXTERNAL(NodeT, identifier) dw::framework::portIndex<NodeT, dw::framework::PortDirection::OUTPUT>(identifier)

namespace dw
{
namespace framework
{

class PortDescriptor
{
public:
    PortDescriptor(
        PortDirection direction, dw::core::StringView name,
        dw::core::StringView typeName, size_t arraySize, bool bindingRequired,
        dw::core::StringView comment);
    PortDirection getDirection() const;

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

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

    bool isArray() const;

    size_t getArraySize() const;

    bool isBindingRequired() const;

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

private:
    PortDirection m_direction;
    dw::core::StringView m_name;
    dw::core::StringView m_typeName;
    size_t m_arraySize;
    bool m_bindingRequired;
    dw::core::StringView m_comment;
};

static constexpr size_t MAX_PORT_DESCRIPTOR_PER_COLLECTION = 256U;

class PortCollectionDescriptor
{
public:
    PortCollectionDescriptor(PortDirection direction, size_t portOffset = 0);

    PortDirection getDirection() const;

    size_t getDescriptorSize() const;

    size_t getPortSize() const;

    const PortDescriptor& getDescriptor(size_t index) const;

    size_t getDescriptorIndex(const char* identifier) const;

    const PortDescriptor& getDescriptor(const char* identifier) const;

    size_t getPortIndex(const char* identifier) const;

    bool isValid(size_t portIndex) const;

    bool isValid(const char* identifier) const;

    void addDescriptor(PortDescriptor&& descriptor);

protected:
    PortDirection m_direction;
    size_t m_portOffset;
    dw::core::VectorFixed<PortDescriptor, MAX_PORT_DESCRIPTOR_PER_COLLECTION> m_descriptors;
};

namespace detail
{

template <
    typename NodeT, PortDirection Direction, size_t Index,
    typename std::enable_if_t<Index == dw::core::tuple_size<decltype(describePorts<NodeT, Direction>())>::value, void>* = nullptr>
void addDescriptors(PortCollectionDescriptor& d)
{
    (void)d;
    return;
}

template <
    typename NodeT, PortDirection Direction, size_t Index,
    typename std::enable_if_t<Index<dw::core::tuple_size<decltype(describePorts<NodeT, Direction>())>::value, void>* = nullptr> void addDescriptors(PortCollectionDescriptor& d)
{
    constexpr auto t = dw::core::get<Index>(describePorts<NodeT, Direction>());
    d.addDescriptor(PortDescriptor(
        Direction,
        std::get<PORT_NAME>(t).data(),
        std::get<PORT_TYPE_NAME>(t).data(),
        std::get<PORT_ARRAY_SIZE>(t),
        std::get<PORT_BINDING>(t) == PortBinding::REQUIRED,
        std::get<PORT_COMMENT>(t).data()));
    addDescriptors<NodeT, Direction, Index + 1>(d);
}

} // namespace detail

template <
    typename NodeT, PortDirection Direction,
    typename std::enable_if_t<Direction == PortDirection::INPUT, void>* = nullptr>
static PortCollectionDescriptor createPortCollectionDescriptor()
{
    PortCollectionDescriptor d(Direction);
    detail::addDescriptors<NodeT, Direction, 0>(d);
    return d;
}

template <
    typename NodeT, PortDirection Direction,
    typename std::enable_if_t<Direction == PortDirection::OUTPUT, void>* = nullptr>
static PortCollectionDescriptor createPortCollectionDescriptor()
{
    PortCollectionDescriptor d(Direction, portSize<NodeT, PortDirection::INPUT>());
    detail::addDescriptors<NodeT, Direction, 0>(d);
    return d;
}

} // namespace framework
} // namespace dw

#endif // DW_FRAMEWORK_PORTCOLLECTIONDESCRIPTOR_HPP_