NodeInstance.hpp

Go to the documentation of this file.

#ifndef CHI_NODE_INSTANCE_HPP
#define CHI_NODE_INSTANCE_HPP

#pragma once

#include "chi/Fwd.hpp"

#include <vector>

#include <boost/uuid/uuid.hpp>
#include <boost/uuid/uuid_generators.hpp>
#include <boost/uuid/uuid_io.hpp>

namespace chi {
struct NodeInstance {
    NodeInstance(GraphFunction* func, std::unique_ptr<NodeType> nodeType, float posX, float posY,
                 boost::uuids::uuid nodeID = boost::uuids::random_generator()());

    ~NodeInstance();

    NodeInstance(NodeInstance&&) = default;

    explicit NodeInstance(const NodeInstance& other,
                          boost::uuids::uuid  id = boost::uuids::random_generator()());

    void setType(std::unique_ptr<NodeType> newType);

    NodeType& type() { return *mType; }
    const NodeType& type() const { return *mType; }
    float x() const { return mX; }
    float y() const { return mY; }
    void setX(float newX) { mX = newX; }
    void setY(float newY) { mY = newY; }
    boost::uuids::uuid id() const { return mId; }

    std::string stringId() const { return boost::uuids::to_string(id()); }

    // connections

    // TODO: better documentation here and OOify
    std::vector<std::vector<std::pair<NodeInstance*, size_t>>> inputExecConnections;

    std::vector<std::pair<NodeInstance*, size_t>> inputDataConnections;

    std::vector<std::pair<NodeInstance*, size_t>> outputExecConnections;

    std::vector<std::vector<std::pair<NodeInstance*, size_t>>> outputDataConnections;

    Context& context() const { return *mContext; }

    GraphFunction& function() const { return *mFunction; }

    GraphModule& module() const { return *mGraphModule; }

private:
    std::unique_ptr<NodeType> mType;

    float mX = 0.f;
    float mY = 0.0;

    boost::uuids::uuid mId;

    Context*       mContext;
    GraphFunction* mFunction    = nullptr;
    GraphModule*   mGraphModule = nullptr;
};


Result connectData(NodeInstance& lhs, size_t lhsConnID, NodeInstance& rhs, size_t rhsConnID);

Result connectExec(NodeInstance& lhs, size_t lhsConnID, NodeInstance& rhs, size_t rhsConnID);

Result disconnectData(NodeInstance& lhs, size_t lhsConnID, NodeInstance& rhs);

Result disconnectExec(NodeInstance& lhs, size_t lhsConnID);


}  // namespace chi

#endif  // CHI_NODE_INSTANCE_HPP