NodeType.h

#pragma once
#include "Engine/Parameter/Template.h"
#include <filesystem>
#include <string>
#include <vector>
 
namespace enzo::nt {
class Node;
class NodeImpl;
class CookContext;
 
using nodeConstructor = NodeImpl* (*)(Node&, CookContext&);
 
struct InputPort
{
    std::string label;
    bool multiInput = false;
 
    bool optional = false;
};
 
struct NodeType
{
    std::string internalName;
 
    std::string typeNamespace;
 
    std::string displayName;
    nodeConstructor ctorFunc = nullptr;
    std::vector<enzo::prm::Template> templates;
 
    std::vector<InputPort> inputPorts;
 
    unsigned int maxOutputs = 1;
 
    std::vector<std::string> tags;
 
    std::filesystem::path folder;
 
    std::string iconPath;
 
    std::string docsPath;
 
    std::string childScopeType;
 
    const std::string& getName() const { return internalName; }
    std::string getFullName() const { return typeNamespace + "::" + internalName; }
    const std::string& getLabel() const { return displayName; }
 
    bool hasChildScope() const { return !childScopeType.empty(); }
 
    bool hasMultiInputPort() const { return !inputPorts.empty() && inputPorts.back().multiInput; }
 
    unsigned int getSinglePortCount() const
    {
        const auto declaredCount = static_cast<unsigned int>(inputPorts.size());
        return hasMultiInputPort() ? declaredCount - 1 : declaredCount;
    }
 
    bool isMultiInputPortAt(unsigned int inputIndex) const
    {
        return hasMultiInputPort() && inputIndex >= getSinglePortCount();
    }
 
    const InputPort* getPortAt(unsigned int inputIndex) const
    {
        if (inputIndex < getSinglePortCount()) return &inputPorts[inputIndex];
        if (hasMultiInputPort()) return &inputPorts.back();
        return nullptr;
    }
 
    std::filesystem::path getIconFile() const
    {
        if (iconPath.empty()) return {};
        return folder / iconPath;
    }
};
} // namespace enzo::nt